http://git-wip-us.apache.org/repos/asf/hive/blob/7c22d74c/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 cdcde51..244b7ab 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 @@ -6443,296 +6443,6 @@ void PartitionSpec::printTo(std::ostream& out) const { } -Index::~Index() throw() { -} - - -void Index::__set_indexName(const std::string& val) { - this->indexName = val; -} - -void Index::__set_indexHandlerClass(const std::string& val) { - this->indexHandlerClass = val; -} - -void Index::__set_dbName(const std::string& val) { - this->dbName = val; -} - -void Index::__set_origTableName(const std::string& val) { - this->origTableName = val; -} - -void Index::__set_createTime(const int32_t val) { - this->createTime = val; -} - -void Index::__set_lastAccessTime(const int32_t val) { - this->lastAccessTime = val; -} - -void Index::__set_indexTableName(const std::string& val) { - this->indexTableName = val; -} - -void Index::__set_sd(const StorageDescriptor& val) { - this->sd = val; -} - -void Index::__set_parameters(const std::map<std::string, std::string> & val) { - this->parameters = val; -} - -void Index::__set_deferredRebuild(const bool val) { - this->deferredRebuild = val; -} - -uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); - - using ::apache::thrift::protocol::TProtocolException; - - - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->indexName); - this->__isset.indexName = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->indexHandlerClass); - this->__isset.indexHandlerClass = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->dbName); - this->__isset.dbName = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 4: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->origTableName); - this->__isset.origTableName = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 5: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32(this->createTime); - this->__isset.createTime = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 6: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32(this->lastAccessTime); - this->__isset.lastAccessTime = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 7: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->indexTableName); - this->__isset.indexTableName = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 8: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->sd.read(iprot); - this->__isset.sd = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 9: - if (ftype == ::apache::thrift::protocol::T_MAP) { - { - this->parameters.clear(); - uint32_t _size279; - ::apache::thrift::protocol::TType _ktype280; - ::apache::thrift::protocol::TType _vtype281; - xfer += iprot->readMapBegin(_ktype280, _vtype281, _size279); - uint32_t _i283; - for (_i283 = 0; _i283 < _size279; ++_i283) - { - std::string _key284; - xfer += iprot->readString(_key284); - std::string& _val285 = this->parameters[_key284]; - xfer += iprot->readString(_val285); - } - xfer += iprot->readMapEnd(); - } - this->__isset.parameters = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 10: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->deferredRebuild); - this->__isset.deferredRebuild = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - -uint32_t Index::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("Index"); - - xfer += oprot->writeFieldBegin("indexName", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->indexName); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("indexHandlerClass", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->indexHandlerClass); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString(this->dbName); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("origTableName", ::apache::thrift::protocol::T_STRING, 4); - xfer += oprot->writeString(this->origTableName); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 5); - xfer += oprot->writeI32(this->createTime); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("lastAccessTime", ::apache::thrift::protocol::T_I32, 6); - xfer += oprot->writeI32(this->lastAccessTime); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("indexTableName", ::apache::thrift::protocol::T_STRING, 7); - xfer += oprot->writeString(this->indexTableName); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("sd", ::apache::thrift::protocol::T_STRUCT, 8); - xfer += this->sd.write(oprot); - xfer += oprot->writeFieldEnd(); - - 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 _iter286; - for (_iter286 = this->parameters.begin(); _iter286 != this->parameters.end(); ++_iter286) - { - xfer += oprot->writeString(_iter286->first); - xfer += oprot->writeString(_iter286->second); - } - xfer += oprot->writeMapEnd(); - } - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("deferredRebuild", ::apache::thrift::protocol::T_BOOL, 10); - xfer += oprot->writeBool(this->deferredRebuild); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - -void swap(Index &a, Index &b) { - using ::std::swap; - swap(a.indexName, b.indexName); - swap(a.indexHandlerClass, b.indexHandlerClass); - swap(a.dbName, b.dbName); - swap(a.origTableName, b.origTableName); - swap(a.createTime, b.createTime); - swap(a.lastAccessTime, b.lastAccessTime); - swap(a.indexTableName, b.indexTableName); - swap(a.sd, b.sd); - swap(a.parameters, b.parameters); - swap(a.deferredRebuild, b.deferredRebuild); - swap(a.__isset, b.__isset); -} - -Index::Index(const Index& other287) { - indexName = other287.indexName; - indexHandlerClass = other287.indexHandlerClass; - dbName = other287.dbName; - origTableName = other287.origTableName; - createTime = other287.createTime; - lastAccessTime = other287.lastAccessTime; - indexTableName = other287.indexTableName; - sd = other287.sd; - parameters = other287.parameters; - deferredRebuild = other287.deferredRebuild; - __isset = other287.__isset; -} -Index& Index::operator=(const Index& other288) { - indexName = other288.indexName; - indexHandlerClass = other288.indexHandlerClass; - dbName = other288.dbName; - origTableName = other288.origTableName; - createTime = other288.createTime; - lastAccessTime = other288.lastAccessTime; - indexTableName = other288.indexTableName; - sd = other288.sd; - parameters = other288.parameters; - deferredRebuild = other288.deferredRebuild; - __isset = other288.__isset; - return *this; -} -void Index::printTo(std::ostream& out) const { - using ::apache::thrift::to_string; - out << "Index("; - out << "indexName=" << to_string(indexName); - out << ", " << "indexHandlerClass=" << to_string(indexHandlerClass); - out << ", " << "dbName=" << to_string(dbName); - out << ", " << "origTableName=" << to_string(origTableName); - out << ", " << "createTime=" << to_string(createTime); - out << ", " << "lastAccessTime=" << to_string(lastAccessTime); - out << ", " << "indexTableName=" << to_string(indexTableName); - out << ", " << "sd=" << to_string(sd); - out << ", " << "parameters=" << to_string(parameters); - out << ", " << "deferredRebuild=" << to_string(deferredRebuild); - out << ")"; -} - - BooleanColumnStatsData::~BooleanColumnStatsData() throw() { } @@ -6864,19 +6574,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other289) { - numTrues = other289.numTrues; - numFalses = other289.numFalses; - numNulls = other289.numNulls; - bitVectors = other289.bitVectors; - __isset = other289.__isset; +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other279) { + numTrues = other279.numTrues; + numFalses = other279.numFalses; + numNulls = other279.numNulls; + bitVectors = other279.bitVectors; + __isset = other279.__isset; } -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other290) { - numTrues = other290.numTrues; - numFalses = other290.numFalses; - numNulls = other290.numNulls; - bitVectors = other290.bitVectors; - __isset = other290.__isset; +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other280) { + numTrues = other280.numTrues; + numFalses = other280.numFalses; + numNulls = other280.numNulls; + bitVectors = other280.bitVectors; + __isset = other280.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -7039,21 +6749,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other291) { - lowValue = other291.lowValue; - highValue = other291.highValue; - numNulls = other291.numNulls; - numDVs = other291.numDVs; - bitVectors = other291.bitVectors; - __isset = other291.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other292) { - lowValue = other292.lowValue; - highValue = other292.highValue; - numNulls = other292.numNulls; - numDVs = other292.numDVs; - bitVectors = other292.bitVectors; - __isset = other292.__isset; +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other281) { + lowValue = other281.lowValue; + highValue = other281.highValue; + numNulls = other281.numNulls; + numDVs = other281.numDVs; + bitVectors = other281.bitVectors; + __isset = other281.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other282) { + lowValue = other282.lowValue; + highValue = other282.highValue; + numNulls = other282.numNulls; + numDVs = other282.numDVs; + bitVectors = other282.bitVectors; + __isset = other282.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -7217,21 +6927,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other293) { - lowValue = other293.lowValue; - highValue = other293.highValue; - numNulls = other293.numNulls; - numDVs = other293.numDVs; - bitVectors = other293.bitVectors; - __isset = other293.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other294) { - lowValue = other294.lowValue; - highValue = other294.highValue; - numNulls = other294.numNulls; - numDVs = other294.numDVs; - bitVectors = other294.bitVectors; - __isset = other294.__isset; +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other283) { + lowValue = other283.lowValue; + highValue = other283.highValue; + numNulls = other283.numNulls; + numDVs = other283.numDVs; + bitVectors = other283.bitVectors; + __isset = other283.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other284) { + lowValue = other284.lowValue; + highValue = other284.highValue; + numNulls = other284.numNulls; + numDVs = other284.numDVs; + bitVectors = other284.bitVectors; + __isset = other284.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -7397,21 +7107,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other295) { - maxColLen = other295.maxColLen; - avgColLen = other295.avgColLen; - numNulls = other295.numNulls; - numDVs = other295.numDVs; - bitVectors = other295.bitVectors; - __isset = other295.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other296) { - maxColLen = other296.maxColLen; - avgColLen = other296.avgColLen; - numNulls = other296.numNulls; - numDVs = other296.numDVs; - bitVectors = other296.bitVectors; - __isset = other296.__isset; +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other285) { + maxColLen = other285.maxColLen; + avgColLen = other285.avgColLen; + numNulls = other285.numNulls; + numDVs = other285.numDVs; + bitVectors = other285.bitVectors; + __isset = other285.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other286) { + maxColLen = other286.maxColLen; + avgColLen = other286.avgColLen; + numNulls = other286.numNulls; + numDVs = other286.numDVs; + bitVectors = other286.bitVectors; + __isset = other286.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -7557,19 +7267,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other297) { - maxColLen = other297.maxColLen; - avgColLen = other297.avgColLen; - numNulls = other297.numNulls; - bitVectors = other297.bitVectors; - __isset = other297.__isset; +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other287) { + maxColLen = other287.maxColLen; + avgColLen = other287.avgColLen; + numNulls = other287.numNulls; + bitVectors = other287.bitVectors; + __isset = other287.__isset; } -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other298) { - maxColLen = other298.maxColLen; - avgColLen = other298.avgColLen; - numNulls = other298.numNulls; - bitVectors = other298.bitVectors; - __isset = other298.__isset; +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other288) { + maxColLen = other288.maxColLen; + avgColLen = other288.avgColLen; + numNulls = other288.numNulls; + bitVectors = other288.bitVectors; + __isset = other288.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -7674,13 +7384,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other299) { - unscaled = other299.unscaled; - scale = other299.scale; +Decimal::Decimal(const Decimal& other289) { + unscaled = other289.unscaled; + scale = other289.scale; } -Decimal& Decimal::operator=(const Decimal& other300) { - unscaled = other300.unscaled; - scale = other300.scale; +Decimal& Decimal::operator=(const Decimal& other290) { + unscaled = other290.unscaled; + scale = other290.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7841,21 +7551,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other301) { - lowValue = other301.lowValue; - highValue = other301.highValue; - numNulls = other301.numNulls; - numDVs = other301.numDVs; - bitVectors = other301.bitVectors; - __isset = other301.__isset; +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other291) { + lowValue = other291.lowValue; + highValue = other291.highValue; + numNulls = other291.numNulls; + numDVs = other291.numDVs; + bitVectors = other291.bitVectors; + __isset = other291.__isset; } -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other302) { - lowValue = other302.lowValue; - highValue = other302.highValue; - numNulls = other302.numNulls; - numDVs = other302.numDVs; - bitVectors = other302.bitVectors; - __isset = other302.__isset; +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other292) { + lowValue = other292.lowValue; + highValue = other292.highValue; + numNulls = other292.numNulls; + numDVs = other292.numDVs; + bitVectors = other292.bitVectors; + __isset = other292.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7941,11 +7651,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other303) { - daysSinceEpoch = other303.daysSinceEpoch; +Date::Date(const Date& other293) { + daysSinceEpoch = other293.daysSinceEpoch; } -Date& Date::operator=(const Date& other304) { - daysSinceEpoch = other304.daysSinceEpoch; +Date& Date::operator=(const Date& other294) { + daysSinceEpoch = other294.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -8105,21 +7815,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other305) { - lowValue = other305.lowValue; - highValue = other305.highValue; - numNulls = other305.numNulls; - numDVs = other305.numDVs; - bitVectors = other305.bitVectors; - __isset = other305.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other306) { - lowValue = other306.lowValue; - highValue = other306.highValue; - numNulls = other306.numNulls; - numDVs = other306.numDVs; - bitVectors = other306.bitVectors; - __isset = other306.__isset; +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other295) { + lowValue = other295.lowValue; + highValue = other295.highValue; + numNulls = other295.numNulls; + numDVs = other295.numDVs; + bitVectors = other295.bitVectors; + __isset = other295.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other296) { + lowValue = other296.lowValue; + highValue = other296.highValue; + numNulls = other296.numNulls; + numDVs = other296.numDVs; + bitVectors = other296.bitVectors; + __isset = other296.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -8305,25 +8015,25 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other307) { - booleanStats = other307.booleanStats; - longStats = other307.longStats; - doubleStats = other307.doubleStats; - stringStats = other307.stringStats; - binaryStats = other307.binaryStats; - decimalStats = other307.decimalStats; - dateStats = other307.dateStats; - __isset = other307.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other308) { - booleanStats = other308.booleanStats; - longStats = other308.longStats; - doubleStats = other308.doubleStats; - stringStats = other308.stringStats; - binaryStats = other308.binaryStats; - decimalStats = other308.decimalStats; - dateStats = other308.dateStats; - __isset = other308.__isset; +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other297) { + booleanStats = other297.booleanStats; + longStats = other297.longStats; + doubleStats = other297.doubleStats; + stringStats = other297.stringStats; + binaryStats = other297.binaryStats; + decimalStats = other297.decimalStats; + dateStats = other297.dateStats; + __isset = other297.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other298) { + booleanStats = other298.booleanStats; + longStats = other298.longStats; + doubleStats = other298.doubleStats; + stringStats = other298.stringStats; + binaryStats = other298.binaryStats; + decimalStats = other298.decimalStats; + dateStats = other298.dateStats; + __isset = other298.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -8451,15 +8161,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other309) { - colName = other309.colName; - colType = other309.colType; - statsData = other309.statsData; +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other299) { + colName = other299.colName; + colType = other299.colType; + statsData = other299.statsData; } -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other310) { - colName = other310.colName; - colType = other310.colType; - statsData = other310.statsData; +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other300) { + colName = other300.colName; + colType = other300.colType; + statsData = other300.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -8622,21 +8332,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other311) { - isTblLevel = other311.isTblLevel; - dbName = other311.dbName; - tableName = other311.tableName; - partName = other311.partName; - lastAnalyzed = other311.lastAnalyzed; - __isset = other311.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other312) { - isTblLevel = other312.isTblLevel; - dbName = other312.dbName; - tableName = other312.tableName; - partName = other312.partName; - lastAnalyzed = other312.lastAnalyzed; - __isset = other312.__isset; +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other301) { + isTblLevel = other301.isTblLevel; + dbName = other301.dbName; + tableName = other301.tableName; + partName = other301.partName; + lastAnalyzed = other301.lastAnalyzed; + __isset = other301.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other302) { + isTblLevel = other302.isTblLevel; + dbName = other302.dbName; + tableName = other302.tableName; + partName = other302.partName; + lastAnalyzed = other302.lastAnalyzed; + __isset = other302.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -8698,14 +8408,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size313; - ::apache::thrift::protocol::TType _etype316; - xfer += iprot->readListBegin(_etype316, _size313); - this->statsObj.resize(_size313); - uint32_t _i317; - for (_i317 = 0; _i317 < _size313; ++_i317) + uint32_t _size303; + ::apache::thrift::protocol::TType _etype306; + xfer += iprot->readListBegin(_etype306, _size303); + this->statsObj.resize(_size303); + uint32_t _i307; + for (_i307 = 0; _i307 < _size303; ++_i307) { - xfer += this->statsObj[_i317].read(iprot); + xfer += this->statsObj[_i307].read(iprot); } xfer += iprot->readListEnd(); } @@ -8742,10 +8452,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 _iter318; - for (_iter318 = this->statsObj.begin(); _iter318 != this->statsObj.end(); ++_iter318) + std::vector<ColumnStatisticsObj> ::const_iterator _iter308; + for (_iter308 = this->statsObj.begin(); _iter308 != this->statsObj.end(); ++_iter308) { - xfer += (*_iter318).write(oprot); + xfer += (*_iter308).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8762,13 +8472,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other319) { - statsDesc = other319.statsDesc; - statsObj = other319.statsObj; +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other309) { + statsDesc = other309.statsDesc; + statsObj = other309.statsObj; } -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other320) { - statsDesc = other320.statsDesc; - statsObj = other320.statsObj; +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other310) { + statsDesc = other310.statsDesc; + statsObj = other310.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8819,14 +8529,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size321; - ::apache::thrift::protocol::TType _etype324; - xfer += iprot->readListBegin(_etype324, _size321); - this->colStats.resize(_size321); - uint32_t _i325; - for (_i325 = 0; _i325 < _size321; ++_i325) + uint32_t _size311; + ::apache::thrift::protocol::TType _etype314; + xfer += iprot->readListBegin(_etype314, _size311); + this->colStats.resize(_size311); + uint32_t _i315; + for (_i315 = 0; _i315 < _size311; ++_i315) { - xfer += this->colStats[_i325].read(iprot); + xfer += this->colStats[_i315].read(iprot); } xfer += iprot->readListEnd(); } @@ -8867,10 +8577,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 _iter326; - for (_iter326 = this->colStats.begin(); _iter326 != this->colStats.end(); ++_iter326) + std::vector<ColumnStatisticsObj> ::const_iterator _iter316; + for (_iter316 = this->colStats.begin(); _iter316 != this->colStats.end(); ++_iter316) { - xfer += (*_iter326).write(oprot); + xfer += (*_iter316).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8891,13 +8601,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other327) { - colStats = other327.colStats; - partsFound = other327.partsFound; +AggrStats::AggrStats(const AggrStats& other317) { + colStats = other317.colStats; + partsFound = other317.partsFound; } -AggrStats& AggrStats::operator=(const AggrStats& other328) { - colStats = other328.colStats; - partsFound = other328.partsFound; +AggrStats& AggrStats::operator=(const AggrStats& other318) { + colStats = other318.colStats; + partsFound = other318.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8948,14 +8658,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size329; - ::apache::thrift::protocol::TType _etype332; - xfer += iprot->readListBegin(_etype332, _size329); - this->colStats.resize(_size329); - uint32_t _i333; - for (_i333 = 0; _i333 < _size329; ++_i333) + uint32_t _size319; + ::apache::thrift::protocol::TType _etype322; + xfer += iprot->readListBegin(_etype322, _size319); + this->colStats.resize(_size319); + uint32_t _i323; + for (_i323 = 0; _i323 < _size319; ++_i323) { - xfer += this->colStats[_i333].read(iprot); + xfer += this->colStats[_i323].read(iprot); } xfer += iprot->readListEnd(); } @@ -8994,10 +8704,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 _iter334; - for (_iter334 = this->colStats.begin(); _iter334 != this->colStats.end(); ++_iter334) + std::vector<ColumnStatistics> ::const_iterator _iter324; + for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); ++_iter324) { - xfer += (*_iter334).write(oprot); + xfer += (*_iter324).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9020,15 +8730,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other335) { - colStats = other335.colStats; - needMerge = other335.needMerge; - __isset = other335.__isset; +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other325) { + colStats = other325.colStats; + needMerge = other325.needMerge; + __isset = other325.__isset; } -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other336) { - colStats = other336.colStats; - needMerge = other336.needMerge; - __isset = other336.__isset; +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other326) { + colStats = other326.colStats; + needMerge = other326.needMerge; + __isset = other326.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -9077,14 +8787,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size337; - ::apache::thrift::protocol::TType _etype340; - xfer += iprot->readListBegin(_etype340, _size337); - this->fieldSchemas.resize(_size337); - uint32_t _i341; - for (_i341 = 0; _i341 < _size337; ++_i341) + uint32_t _size327; + ::apache::thrift::protocol::TType _etype330; + xfer += iprot->readListBegin(_etype330, _size327); + this->fieldSchemas.resize(_size327); + uint32_t _i331; + for (_i331 = 0; _i331 < _size327; ++_i331) { - xfer += this->fieldSchemas[_i341].read(iprot); + xfer += this->fieldSchemas[_i331].read(iprot); } xfer += iprot->readListEnd(); } @@ -9097,17 +8807,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size342; - ::apache::thrift::protocol::TType _ktype343; - ::apache::thrift::protocol::TType _vtype344; - xfer += iprot->readMapBegin(_ktype343, _vtype344, _size342); - uint32_t _i346; - for (_i346 = 0; _i346 < _size342; ++_i346) + uint32_t _size332; + ::apache::thrift::protocol::TType _ktype333; + ::apache::thrift::protocol::TType _vtype334; + xfer += iprot->readMapBegin(_ktype333, _vtype334, _size332); + uint32_t _i336; + for (_i336 = 0; _i336 < _size332; ++_i336) { - std::string _key347; - xfer += iprot->readString(_key347); - std::string& _val348 = this->properties[_key347]; - xfer += iprot->readString(_val348); + std::string _key337; + xfer += iprot->readString(_key337); + std::string& _val338 = this->properties[_key337]; + xfer += iprot->readString(_val338); } xfer += iprot->readMapEnd(); } @@ -9136,10 +8846,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 _iter349; - for (_iter349 = this->fieldSchemas.begin(); _iter349 != this->fieldSchemas.end(); ++_iter349) + std::vector<FieldSchema> ::const_iterator _iter339; + for (_iter339 = this->fieldSchemas.begin(); _iter339 != this->fieldSchemas.end(); ++_iter339) { - xfer += (*_iter349).write(oprot); + xfer += (*_iter339).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9148,11 +8858,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 _iter350; - for (_iter350 = this->properties.begin(); _iter350 != this->properties.end(); ++_iter350) + std::map<std::string, std::string> ::const_iterator _iter340; + for (_iter340 = this->properties.begin(); _iter340 != this->properties.end(); ++_iter340) { - xfer += oprot->writeString(_iter350->first); - xfer += oprot->writeString(_iter350->second); + xfer += oprot->writeString(_iter340->first); + xfer += oprot->writeString(_iter340->second); } xfer += oprot->writeMapEnd(); } @@ -9170,15 +8880,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other351) { - fieldSchemas = other351.fieldSchemas; - properties = other351.properties; - __isset = other351.__isset; +Schema::Schema(const Schema& other341) { + fieldSchemas = other341.fieldSchemas; + properties = other341.properties; + __isset = other341.__isset; } -Schema& Schema::operator=(const Schema& other352) { - fieldSchemas = other352.fieldSchemas; - properties = other352.properties; - __isset = other352.__isset; +Schema& Schema::operator=(const Schema& other342) { + fieldSchemas = other342.fieldSchemas; + properties = other342.properties; + __isset = other342.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -9223,17 +8933,17 @@ uint32_t EnvironmentContext::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 _size343; + ::apache::thrift::protocol::TType _ktype344; + ::apache::thrift::protocol::TType _vtype345; + xfer += iprot->readMapBegin(_ktype344, _vtype345, _size343); + uint32_t _i347; + for (_i347 = 0; _i347 < _size343; ++_i347) { - std::string _key358; - xfer += iprot->readString(_key358); - std::string& _val359 = this->properties[_key358]; - xfer += iprot->readString(_val359); + std::string _key348; + xfer += iprot->readString(_key348); + std::string& _val349 = this->properties[_key348]; + xfer += iprot->readString(_val349); } xfer += iprot->readMapEnd(); } @@ -9262,11 +8972,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 _iter360; - for (_iter360 = this->properties.begin(); _iter360 != this->properties.end(); ++_iter360) + std::map<std::string, std::string> ::const_iterator _iter350; + for (_iter350 = this->properties.begin(); _iter350 != this->properties.end(); ++_iter350) { - xfer += oprot->writeString(_iter360->first); - xfer += oprot->writeString(_iter360->second); + xfer += oprot->writeString(_iter350->first); + xfer += oprot->writeString(_iter350->second); } xfer += oprot->writeMapEnd(); } @@ -9283,13 +8993,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other361) { - properties = other361.properties; - __isset = other361.__isset; +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other351) { + properties = other351.properties; + __isset = other351.__isset; } -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other362) { - properties = other362.properties; - __isset = other362.__isset; +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other352) { + properties = other352.properties; + __isset = other352.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -9391,13 +9101,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other363) { - db_name = other363.db_name; - tbl_name = other363.tbl_name; +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other353) { + db_name = other353.db_name; + tbl_name = other353.tbl_name; } -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other364) { - db_name = other364.db_name; - tbl_name = other364.tbl_name; +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other354) { + db_name = other354.db_name; + tbl_name = other354.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -9443,14 +9153,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size365; - ::apache::thrift::protocol::TType _etype368; - xfer += iprot->readListBegin(_etype368, _size365); - this->primaryKeys.resize(_size365); - uint32_t _i369; - for (_i369 = 0; _i369 < _size365; ++_i369) + uint32_t _size355; + ::apache::thrift::protocol::TType _etype358; + xfer += iprot->readListBegin(_etype358, _size355); + this->primaryKeys.resize(_size355); + uint32_t _i359; + for (_i359 = 0; _i359 < _size355; ++_i359) { - xfer += this->primaryKeys[_i369].read(iprot); + xfer += this->primaryKeys[_i359].read(iprot); } xfer += iprot->readListEnd(); } @@ -9481,10 +9191,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 _iter370; - for (_iter370 = this->primaryKeys.begin(); _iter370 != this->primaryKeys.end(); ++_iter370) + std::vector<SQLPrimaryKey> ::const_iterator _iter360; + for (_iter360 = this->primaryKeys.begin(); _iter360 != this->primaryKeys.end(); ++_iter360) { - xfer += (*_iter370).write(oprot); + xfer += (*_iter360).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9500,11 +9210,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other371) { - primaryKeys = other371.primaryKeys; +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other361) { + primaryKeys = other361.primaryKeys; } -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other372) { - primaryKeys = other372.primaryKeys; +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other362) { + primaryKeys = other362.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -9635,19 +9345,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other373) { - parent_db_name = other373.parent_db_name; - parent_tbl_name = other373.parent_tbl_name; - foreign_db_name = other373.foreign_db_name; - foreign_tbl_name = other373.foreign_tbl_name; - __isset = other373.__isset; +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other363) { + parent_db_name = other363.parent_db_name; + parent_tbl_name = other363.parent_tbl_name; + foreign_db_name = other363.foreign_db_name; + foreign_tbl_name = other363.foreign_tbl_name; + __isset = other363.__isset; } -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other374) { - parent_db_name = other374.parent_db_name; - parent_tbl_name = other374.parent_tbl_name; - foreign_db_name = other374.foreign_db_name; - foreign_tbl_name = other374.foreign_tbl_name; - __isset = other374.__isset; +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other364) { + parent_db_name = other364.parent_db_name; + parent_tbl_name = other364.parent_tbl_name; + foreign_db_name = other364.foreign_db_name; + foreign_tbl_name = other364.foreign_tbl_name; + __isset = other364.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -9695,14 +9405,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size375; - ::apache::thrift::protocol::TType _etype378; - xfer += iprot->readListBegin(_etype378, _size375); - this->foreignKeys.resize(_size375); - uint32_t _i379; - for (_i379 = 0; _i379 < _size375; ++_i379) + uint32_t _size365; + ::apache::thrift::protocol::TType _etype368; + xfer += iprot->readListBegin(_etype368, _size365); + this->foreignKeys.resize(_size365); + uint32_t _i369; + for (_i369 = 0; _i369 < _size365; ++_i369) { - xfer += this->foreignKeys[_i379].read(iprot); + xfer += this->foreignKeys[_i369].read(iprot); } xfer += iprot->readListEnd(); } @@ -9733,10 +9443,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 _iter380; - for (_iter380 = this->foreignKeys.begin(); _iter380 != this->foreignKeys.end(); ++_iter380) + std::vector<SQLForeignKey> ::const_iterator _iter370; + for (_iter370 = this->foreignKeys.begin(); _iter370 != this->foreignKeys.end(); ++_iter370) { - xfer += (*_iter380).write(oprot); + xfer += (*_iter370).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9752,11 +9462,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other381) { - foreignKeys = other381.foreignKeys; +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other371) { + foreignKeys = other371.foreignKeys; } -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other382) { - foreignKeys = other382.foreignKeys; +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other372) { + foreignKeys = other372.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9858,13 +9568,13 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other383) { - db_name = other383.db_name; - tbl_name = other383.tbl_name; +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other373) { + db_name = other373.db_name; + tbl_name = other373.tbl_name; } -UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other384) { - db_name = other384.db_name; - tbl_name = other384.tbl_name; +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other374) { + db_name = other374.db_name; + tbl_name = other374.tbl_name; return *this; } void UniqueConstraintsRequest::printTo(std::ostream& out) const { @@ -9910,14 +9620,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size385; - ::apache::thrift::protocol::TType _etype388; - xfer += iprot->readListBegin(_etype388, _size385); - this->uniqueConstraints.resize(_size385); - uint32_t _i389; - for (_i389 = 0; _i389 < _size385; ++_i389) + uint32_t _size375; + ::apache::thrift::protocol::TType _etype378; + xfer += iprot->readListBegin(_etype378, _size375); + this->uniqueConstraints.resize(_size375); + uint32_t _i379; + for (_i379 = 0; _i379 < _size375; ++_i379) { - xfer += this->uniqueConstraints[_i389].read(iprot); + xfer += this->uniqueConstraints[_i379].read(iprot); } xfer += iprot->readListEnd(); } @@ -9948,10 +9658,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 _iter390; - for (_iter390 = this->uniqueConstraints.begin(); _iter390 != this->uniqueConstraints.end(); ++_iter390) + std::vector<SQLUniqueConstraint> ::const_iterator _iter380; + for (_iter380 = this->uniqueConstraints.begin(); _iter380 != this->uniqueConstraints.end(); ++_iter380) { - xfer += (*_iter390).write(oprot); + xfer += (*_iter380).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9967,11 +9677,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) { swap(a.uniqueConstraints, b.uniqueConstraints); } -UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other391) { - uniqueConstraints = other391.uniqueConstraints; +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other381) { + uniqueConstraints = other381.uniqueConstraints; } -UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other392) { - uniqueConstraints = other392.uniqueConstraints; +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other382) { + uniqueConstraints = other382.uniqueConstraints; return *this; } void UniqueConstraintsResponse::printTo(std::ostream& out) const { @@ -10073,13 +9783,13 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other393) { - db_name = other393.db_name; - tbl_name = other393.tbl_name; +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other383) { + db_name = other383.db_name; + tbl_name = other383.tbl_name; } -NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other394) { - db_name = other394.db_name; - tbl_name = other394.tbl_name; +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other384) { + db_name = other384.db_name; + tbl_name = other384.tbl_name; return *this; } void NotNullConstraintsRequest::printTo(std::ostream& out) const { @@ -10125,14 +9835,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size395; - ::apache::thrift::protocol::TType _etype398; - xfer += iprot->readListBegin(_etype398, _size395); - this->notNullConstraints.resize(_size395); - uint32_t _i399; - for (_i399 = 0; _i399 < _size395; ++_i399) + uint32_t _size385; + ::apache::thrift::protocol::TType _etype388; + xfer += iprot->readListBegin(_etype388, _size385); + this->notNullConstraints.resize(_size385); + uint32_t _i389; + for (_i389 = 0; _i389 < _size385; ++_i389) { - xfer += this->notNullConstraints[_i399].read(iprot); + xfer += this->notNullConstraints[_i389].read(iprot); } xfer += iprot->readListEnd(); } @@ -10163,10 +9873,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 _iter400; - for (_iter400 = this->notNullConstraints.begin(); _iter400 != this->notNullConstraints.end(); ++_iter400) + std::vector<SQLNotNullConstraint> ::const_iterator _iter390; + for (_iter390 = this->notNullConstraints.begin(); _iter390 != this->notNullConstraints.end(); ++_iter390) { - xfer += (*_iter400).write(oprot); + xfer += (*_iter390).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10182,11 +9892,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) { swap(a.notNullConstraints, b.notNullConstraints); } -NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other401) { - notNullConstraints = other401.notNullConstraints; +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other391) { + notNullConstraints = other391.notNullConstraints; } -NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other402) { - notNullConstraints = other402.notNullConstraints; +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other392) { + notNullConstraints = other392.notNullConstraints; return *this; } void NotNullConstraintsResponse::printTo(std::ostream& out) const { @@ -10288,13 +9998,13 @@ void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other403) { - db_name = other403.db_name; - tbl_name = other403.tbl_name; +DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other393) { + db_name = other393.db_name; + tbl_name = other393.tbl_name; } -DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other404) { - db_name = other404.db_name; - tbl_name = other404.tbl_name; +DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other394) { + db_name = other394.db_name; + tbl_name = other394.tbl_name; return *this; } void DefaultConstraintsRequest::printTo(std::ostream& out) const { @@ -10340,14 +10050,14 @@ uint32_t DefaultConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size405; - ::apache::thrift::protocol::TType _etype408; - xfer += iprot->readListBegin(_etype408, _size405); - this->defaultConstraints.resize(_size405); - uint32_t _i409; - for (_i409 = 0; _i409 < _size405; ++_i409) + uint32_t _size395; + ::apache::thrift::protocol::TType _etype398; + xfer += iprot->readListBegin(_etype398, _size395); + this->defaultConstraints.resize(_size395); + uint32_t _i399; + for (_i399 = 0; _i399 < _size395; ++_i399) { - xfer += this->defaultConstraints[_i409].read(iprot); + xfer += this->defaultConstraints[_i399].read(iprot); } xfer += iprot->readListEnd(); } @@ -10378,10 +10088,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 _iter410; - for (_iter410 = this->defaultConstraints.begin(); _iter410 != this->defaultConstraints.end(); ++_iter410) + std::vector<SQLDefaultConstraint> ::const_iterator _iter400; + for (_iter400 = this->defaultConstraints.begin(); _iter400 != this->defaultConstraints.end(); ++_iter400) { - xfer += (*_iter410).write(oprot); + xfer += (*_iter400).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10397,11 +10107,11 @@ void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b) { swap(a.defaultConstraints, b.defaultConstraints); } -DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other411) { - defaultConstraints = other411.defaultConstraints; +DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other401) { + defaultConstraints = other401.defaultConstraints; } -DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other412) { - defaultConstraints = other412.defaultConstraints; +DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other402) { + defaultConstraints = other402.defaultConstraints; return *this; } void DefaultConstraintsResponse::printTo(std::ostream& out) const { @@ -10523,15 +10233,15 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.constraintname, b.constraintname); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other413) { - dbname = other413.dbname; - tablename = other413.tablename; - constraintname = other413.constraintname; +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other403) { + dbname = other403.dbname; + tablename = other403.tablename; + constraintname = other403.constraintname; } -DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other414) { - dbname = other414.dbname; - tablename = other414.tablename; - constraintname = other414.constraintname; +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other404) { + dbname = other404.dbname; + tablename = other404.tablename; + constraintname = other404.constraintname; return *this; } void DropConstraintRequest::printTo(std::ostream& out) const { @@ -10578,14 +10288,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - uint32_t _size415; - ::apache::thrift::protocol::TType _etype418; - xfer += iprot->readListBegin(_etype418, _size415); - this->primaryKeyCols.resize(_size415); - uint32_t _i419; - for (_i419 = 0; _i419 < _size415; ++_i419) + uint32_t _size405; + ::apache::thrift::protocol::TType _etype408; + xfer += iprot->readListBegin(_etype408, _size405); + this->primaryKeyCols.resize(_size405); + uint32_t _i409; + for (_i409 = 0; _i409 < _size405; ++_i409) { - xfer += this->primaryKeyCols[_i419].read(iprot); + xfer += this->primaryKeyCols[_i409].read(iprot); } xfer += iprot->readListEnd(); } @@ -10616,10 +10326,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 _iter420; - for (_iter420 = this->primaryKeyCols.begin(); _iter420 != this->primaryKeyCols.end(); ++_iter420) + std::vector<SQLPrimaryKey> ::const_iterator _iter410; + for (_iter410 = this->primaryKeyCols.begin(); _iter410 != this->primaryKeyCols.end(); ++_iter410) { - xfer += (*_iter420).write(oprot); + xfer += (*_iter410).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10635,11 +10345,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other421) { - primaryKeyCols = other421.primaryKeyCols; +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other411) { + primaryKeyCols = other411.primaryKeyCols; } -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other422) { - primaryKeyCols = other422.primaryKeyCols; +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other412) { + primaryKeyCols = other412.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -10684,14 +10394,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - uint32_t _size423; - ::apache::thrift::protocol::TType _etype426; - xfer += iprot->readListBegin(_etype426, _size423); - this->foreignKeyCols.resize(_size423); - uint32_t _i427; - for (_i427 = 0; _i427 < _size423; ++_i427) + uint32_t _size413; + ::apache::thrift::protocol::TType _etype416; + xfer += iprot->readListBegin(_etype416, _size413); + this->foreignKeyCols.resize(_size413); + uint32_t _i417; + for (_i417 = 0; _i417 < _size413; ++_i417) { - xfer += this->foreignKeyCols[_i427].read(iprot); + xfer += this->foreignKeyCols[_i417].read(iprot); } xfer += iprot->readListEnd(); } @@ -10722,10 +10432,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 _iter428; - for (_iter428 = this->foreignKeyCols.begin(); _iter428 != this->foreignKeyCols.end(); ++_iter428) + std::vector<SQLForeignKey> ::const_iterator _iter418; + for (_iter418 = this->foreignKeyCols.begin(); _iter418 != this->foreignKeyCols.end(); ++_iter418) { - xfer += (*_iter428).write(oprot); + xfer += (*_iter418).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10741,11 +10451,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other429) { - foreignKeyCols = other429.foreignKeyCols; +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other419) { + foreignKeyCols = other419.foreignKeyCols; } -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other430) { - foreignKeyCols = other430.foreignKeyCols; +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other420) { + foreignKeyCols = other420.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -10790,14 +10500,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraintCols.clear(); - uint32_t _size431; - ::apache::thrift::protocol::TType _etype434; - xfer += iprot->readListBegin(_etype434, _size431); - this->uniqueConstraintCols.resize(_size431); - uint32_t _i435; - for (_i435 = 0; _i435 < _size431; ++_i435) + uint32_t _size421; + ::apache::thrift::protocol::TType _etype424; + xfer += iprot->readListBegin(_etype424, _size421); + this->uniqueConstraintCols.resize(_size421); + uint32_t _i425; + for (_i425 = 0; _i425 < _size421; ++_i425) { - xfer += this->uniqueConstraintCols[_i435].read(iprot); + xfer += this->uniqueConstraintCols[_i425].read(iprot); } xfer += iprot->readListEnd(); } @@ -10828,10 +10538,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 _iter436; - for (_iter436 = this->uniqueConstraintCols.begin(); _iter436 != this->uniqueConstraintCols.end(); ++_iter436) + std::vector<SQLUniqueConstraint> ::const_iterator _iter426; + for (_iter426 = this->uniqueConstraintCols.begin(); _iter426 != this->uniqueConstraintCols.end(); ++_iter426) { - xfer += (*_iter436).write(oprot); + xfer += (*_iter426).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10847,11 +10557,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) { swap(a.uniqueConstraintCols, b.uniqueConstraintCols); } -AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other437) { - uniqueConstraintCols = other437.uniqueConstraintCols; +AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other427) { + uniqueConstraintCols = other427.uniqueConstraintCols; } -AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other438) { - uniqueConstraintCols = other438.uniqueConstraintCols; +AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other428) { + uniqueConstraintCols = other428.uniqueConstraintCols; return *this; } void AddUniqueConstraintRequest::printTo(std::ostream& out) const { @@ -10896,14 +10606,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraintCols.clear(); - uint32_t _size439; - ::apache::thrift::protocol::TType _etype442; - xfer += iprot->readListBegin(_etype442, _size439); - this->notNullConstraintCols.resize(_size439); - uint32_t _i443; - for (_i443 = 0; _i443 < _size439; ++_i443) + uint32_t _size429; + ::apache::thrift::protocol::TType _etype432; + xfer += iprot->readListBegin(_etype432, _size429); + this->notNullConstraintCols.resize(_size429); + uint32_t _i433; + for (_i433 = 0; _i433 < _size429; ++_i433) { - xfer += this->notNullConstraintCols[_i443].read(iprot); + xfer += this->notNullConstraintCols[_i433].read(iprot); } xfer += iprot->readListEnd(); } @@ -10934,10 +10644,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 _iter444; - for (_iter444 = this->notNullConstraintCols.begin(); _iter444 != this->notNullConstraintCols.end(); ++_iter444) + std::vector<SQLNotNullConstraint> ::const_iterator _iter434; + for (_iter434 = this->notNullConstraintCols.begin(); _iter434 != this->notNullConstraintCols.end(); ++_iter434) { - xfer += (*_iter444).write(oprot); + xfer += (*_iter434).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10953,11 +10663,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) { swap(a.notNullConstraintCols, b.notNullConstraintCols); } -AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other445) { - notNullConstraintCols = other445.notNullConstraintCols; +AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other435) { + notNullConstraintCols = other435.notNullConstraintCols; } -AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other446) { - notNullConstraintCols = other446.notNullConstraintCols; +AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other436) { + notNullConstraintCols = other436.notNullConstraintCols; return *this; } void AddNotNullConstraintRequest::printTo(std::ostream& out) const { @@ -11002,14 +10712,14 @@ uint32_t AddDefaultConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraintCols.clear(); - uint32_t _size447; - ::apache::thrift::protocol::TType _etype450; - xfer += iprot->readListBegin(_etype450, _size447); - this->defaultConstraintCols.resize(_size447); - uint32_t _i451; - for (_i451 = 0; _i451 < _size447; ++_i451) + uint32_t _size437; + ::apache::thrift::protocol::TType _etype440; + xfer += iprot->readListBegin(_etype440, _size437); + this->defaultConstraintCols.resize(_size437); + uint32_t _i441; + for (_i441 = 0; _i441 < _size437; ++_i441) { - xfer += this->defaultConstraintCols[_i451].read(iprot); + xfer += this->defaultConstraintCols[_i441].read(iprot); } xfer += iprot->readListEnd(); } @@ -11040,10 +10750,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 _iter452; - for (_iter452 = this->defaultConstraintCols.begin(); _iter452 != this->defaultConstraintCols.end(); ++_iter452) + std::vector<SQLDefaultConstraint> ::const_iterator _iter442; + for (_iter442 = this->defaultConstraintCols.begin(); _iter442 != this->defaultConstraintCols.end(); ++_iter442) { - xfer += (*_iter452).write(oprot); + xfer += (*_iter442).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11059,11 +10769,11 @@ void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b) { swap(a.defaultConstraintCols, b.defaultConstraintCols); } -AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other453) { - defaultConstraintCols = other453.defaultConstraintCols; +AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other443) { + defaultConstraintCols = other443.defaultConstraintCols; } -AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other454) { - defaultConstraintCols = other454.defaultConstraintCols; +AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other444) { + defaultConstraintCols = other444.defaultConstraintCols; return *this; } void AddDefaultConstraintRequest::printTo(std::ostream& out) const { @@ -11113,14 +10823,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size455; - ::apache::thrift::protocol::TType _etype458; - xfer += iprot->readListBegin(_etype458, _size455); - this->partitions.resize(_size455); - uint32_t _i459; - for (_i459 = 0; _i459 < _size455; ++_i459) + uint32_t _size445; + ::apache::thrift::protocol::TType _etype448; + xfer += iprot->readListBegin(_etype448, _size445); + this->partitions.resize(_size445); + uint32_t _i449; + for (_i449 = 0; _i449 < _size445; ++_i449) { - xfer += this->partitions[_i459].read(iprot); + xfer += this->partitions[_i449].read(iprot); } xfer += iprot->readListEnd(); } @@ -11161,10 +10871,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op 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 _iter460; - for (_iter460 = this->partitions.begin(); _iter460 != this->partitions.end(); ++_iter460) + std::vector<Partition> ::const_iterator _iter450; + for (_iter450 = this->partitions.begin(); _iter450 != this->partitions.end(); ++_iter450) { - xfer += (*_iter460).write(oprot); + xfer += (*_iter450).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11185,13 +10895,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other461) { - partitions = other461.partitions; - hasUnknownPartitions = other461.hasUnknownPartitions; +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other451) { + partitions = other451.partitions; + hasUnknownPartitions = other451.hasUnknownPartitions; } -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other462) { - partitions = other462.partitions; - hasUnknownPartitions = other462.hasUnknownPartitions; +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other452) { + partitions = other452.partitions; + hasUnknownPartitions = other452.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -11353,21 +11063,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other463) { - dbName = other463.dbName; - tblName = other463.tblName; - expr = other463.expr; - defaultPartitionName = other463.defaultPartitionName; - maxParts = other463.maxParts; - __isset = other463.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other464) { - dbName = other464.dbName; - tblName = other464.tblName; - expr = other464.expr; - defaultPartitionName = other464.defaultPartitionName; - maxParts = other464.maxParts; - __isset = other464.__isset; +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other453) { + dbName = other453.dbName; + tblName = other453.tblName; + expr = other453.expr; + defaultPartitionName = other453.defaultPartitionName; + maxParts = other453.maxParts; + __isset = other453.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other454) { + dbName = other454.dbName; + tblName = other454.tblName; + expr = other454.expr; + defaultPartitionName = other454.defaultPartitionName; + maxParts = other454.maxParts; + __isset = other454.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -11416,14 +11126,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size465; - ::apache::thrift::protocol::TType _etype468; - xfer += iprot->readListBegin(_etype468, _size465); - this->tableStats.resize(_size465); - uint32_t _i469; - for (_i469 = 0; _i469 < _size465; ++_i469) + uint32_t _size455; + ::apache::thrift::protocol::TType _etype458; + xfer += iprot->readListBegin(_etype458, _size455); + this->tableStats.resize(_size455); + uint32_t _i459; + for (_i459 = 0; _i459 < _size455; ++_i459) { - xfer += this->tableStats[_i469].read(iprot); + xfer += this->tableStats[_i459].read(iprot); } xfer += iprot->readListEnd(); } @@ -11454,10 +11164,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tableStats.size())); - std::vector<ColumnStatisticsObj> ::const_iterator _iter470; - for (_iter470 = this->tableStats.begin(); _iter470 != this->tableStats.end(); ++_iter470) + std::vector<ColumnStatisticsObj> ::const_iterator _iter460; + for (_iter460 = this->tableStats.begin(); _iter460 != this->tableStats.end(); ++_iter460) { - xfer += (*_iter470).write(oprot); + xfer += (*_iter460).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11473,11 +11183,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other471) { - tableStats = other471.tableStats; +TableStatsResult::TableStatsResult(const TableStatsResult& other461) { + tableStats = other461.tableStats; } -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other472) { - tableStats = other472.tableStats; +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other462) { + tableStats = other462.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -11522,26 +11232,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size473; - ::apache::thrift::protocol::TType _ktype474; - ::apache::thrift::protocol::TType _vtype475; - xfer += iprot->readMapBegin(_ktype474, _vtype475, _size473); - uint32_t _i477; - for (_i477 = 0; _i477 < _size473; ++_i477) + uint32_t _size463; + ::apache::thrift::protocol::TType _ktype464; + ::apache::thrift::protocol::TType _vtype465; + xfer += iprot->readMapBegin(_ktype464, _vtype465, _size463); + uint32_t _i467; + for (_i467 = 0; _i467 < _size463; ++_i467) { - std::string _key478; - xfer += iprot->readString(_key478); - std::vector<ColumnStatisticsObj> & _val479 = this->partStats[_key478]; + std::string _key468; + xfer += iprot->readString(_key468); + std::vector<ColumnStatisticsObj> & _val469 = this->partStats[_key468]; { - _val479.clear(); - uint32_t _size480; - ::apache::thrift::protocol::TType _etype483; - xfer += iprot->readListBegin(_etype483, _size480); - _val479.resize(_size480); - uint32_t _i484; - for (_i484 = 0; _i484 < _size480; ++_i484) + _val469.clear(); + uint32_t _size470; + ::apache::thrift::protocol::TType _etype473; + xfer += iprot->readListBegin(_etype473, _size470); + _val469.resize(_size470); + uint32_t _i474; + for (_i474 = 0; _i474 < _size470; ++_i474) { - xfer += _val479[_i484].read(iprot); + xfer += _val469[_i474].read(iprot); } xfer += iprot->readListEnd(); } @@ -11575,16 +11285,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->partStats.size())); - std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter485; - for (_iter485 = this->partStats.begin(); _iter485 != this->partStats.end(); ++_iter485) + std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter475; + for (_iter475 = this->partStats.begin(); _iter475 != this->partStats.end(); ++_iter475) { - xfer += oprot->writeString(_iter485->first); + xfer += oprot->writeString(_iter475->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter485->second.size())); - std::vector<ColumnStatisticsObj> ::const_iterator _iter486; - for (_iter486 = _iter485->second.begin(); _iter486 != _iter485->second.end(); ++_iter486) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter475->second.size())); + std::vector<ColumnStatisticsObj> ::const_iterator _iter476; + for (_iter476 = _iter475->second.begin(); _iter476 != _iter475->second.end(); ++_iter476) { - xfer += (*_iter486).write(oprot); + xfer += (*_iter476).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11603,11 +11313,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { swap(a.partStats, b.partStats); } -PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other487) { - partStats = other487.partStats; +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other477) { + partStats = other477.partStats; } -PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other488) { - partStats = other488.partStats; +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other478) { + partStats = other478.partStats; return *this; } void PartitionsStatsResult::printTo(std::ostream& out) const { @@ -11678,14 +11388,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size489; - ::apache::thrift::protocol::TType _etype492; - xfer += iprot->readListBegin(_etype492, _size489); - this->colNames.resize(_size489); - uint32_t _i493; - for (_i493 = 0; _i493 < _size489; ++_i493) + uint32_t _size479; + ::apache::thrift::protocol::TType _etype482; + xfer += iprot->readListBegin(_etype482, _size479); + this->colNames.resize(_size479); + uint32_t _i483; + for (_i483 = 0; _i483 < _size479; ++_i483) { - xfer += iprot->readString(this->colNames[_i493]); + xfer += iprot->readString(this->colNames[_i483]); } xfer += iprot->readListEnd(); } @@ -11728,10 +11438,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size())); - std::vector<std::string> ::const_iterator _iter494; - for (_iter494 = this->colNames.begin(); _iter494 != this->colNames.end(); ++_iter494) + std::vector<std::string> ::const_iterator _iter484; + for (_iter484 = this->colNames.begin(); _iter484 != this->colNames.end(); ++_iter484) { - xfer += oprot->writeString((*_iter494)); + xfer += oprot->writeString((*_iter484)); } xfer += oprot->writeListEnd(); } @@ -11749,15 +11459,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { swap(a.colNames, b.colNames); } -TableStatsRequest::TableStatsRequest(const TableStatsRequest& other495) { - dbName = other495.dbName; - tblName = other495.tblName; - colNames = other495.colNames; +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other485) { + dbName = other485.dbName; + tblName = other485.tblName; + colNames = other485.colNames; } -TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other496) { - dbName = other496.dbName; - tblName = other496.tblName; - colNames = other496.colNames; +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other486) { + dbName = other486.dbName; + tblName = other486.tblName; + colNames = other486.colNames; return *this; } void TableStatsRequest::printTo(std::ostream& out) const { @@ -11835,14 +11545,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size497; - ::apache::thrift::protocol::TType _etype500; - xfer += iprot->readListBegin(_etype500, _size497); - this->colNames.resize(_size497); - uint32_t _i501; - for (_i501 = 0; _i501 < _size497; ++_i501) + uint32_t _size487; + ::apache::thrift::protocol::TType _etype490; + xfer += iprot->readListBegin(_etype490, _size487); + this->colNames.resize(_size487); + uint32_t _i491; + for (_i491 = 0; _i491 < _size487; ++_i491) { - xfer += iprot->readString(this->colNames[_i501]); + xfer += iprot->readString(this->colNames[_i491]); } xfer += iprot->readListEnd(); } @@ -11855,14 +11565,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size502; - ::apache::thrift::protocol::TType _etype505; - xfer += iprot->readListBegin(_etype505, _size502); - this->partNames.resize(_size502); - uint32_t _i506; - for (_i506 = 0; _i506 < _size502; ++_i506) + uint32_t _size492; + ::apache::thrift::protocol::TType _etype495; + xfer += iprot->readListBegin(_etype495, _size492); + this->partNames.resize(_size492); + uint32_t _i496; + for (_i496 = 0; _i496 < _size492; ++_i496) { - xfer += iprot->readString(this->partNames[_i506]); + xfer += iprot->readString(this->partNames[_i496]); } xfer += iprot->readListEnd(); } @@ -11907,10 +11617,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size())); - std::vector<std::string> ::const_iterator _iter507; - for (_iter507 = this->colNames.begin(); _iter507 != this->colNames.end(); ++_iter507) + std::vector<std::string> ::const_iterator _iter497; + for (_iter497 = this->colNames.begin(); _iter497 != this->colNames.end()
<TRUNCATED>
