http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/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 bf1c5a1..98021b2 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 @@ -149,6 +149,72 @@ const char* _kEventRequestTypeNames[] = { }; const std::map<int, const char*> _EventRequestType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kEventRequestTypeValues, _kEventRequestTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +int _kSerdeTypeValues[] = { + SerdeType::HIVE, + SerdeType::SCHEMA_REGISTRY +}; +const char* _kSerdeTypeNames[] = { + "HIVE", + "SCHEMA_REGISTRY" +}; +const std::map<int, const char*> _SerdeType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSerdeTypeValues, _kSerdeTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +int _kSchemaTypeValues[] = { + SchemaType::HIVE, + SchemaType::AVRO +}; +const char* _kSchemaTypeNames[] = { + "HIVE", + "AVRO" +}; +const std::map<int, const char*> _SchemaType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSchemaTypeValues, _kSchemaTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +int _kSchemaCompatibilityValues[] = { + SchemaCompatibility::NONE, + SchemaCompatibility::BACKWARD, + SchemaCompatibility::FORWARD, + SchemaCompatibility::BOTH +}; +const char* _kSchemaCompatibilityNames[] = { + "NONE", + "BACKWARD", + "FORWARD", + "BOTH" +}; +const std::map<int, const char*> _SchemaCompatibility_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kSchemaCompatibilityValues, _kSchemaCompatibilityNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +int _kSchemaValidationValues[] = { + SchemaValidation::LATEST, + SchemaValidation::ALL +}; +const char* _kSchemaValidationNames[] = { + "LATEST", + "ALL" +}; +const std::map<int, const char*> _SchemaValidation_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSchemaValidationValues, _kSchemaValidationNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +int _kSchemaVersionStateValues[] = { + SchemaVersionState::INITIATED, + SchemaVersionState::START_REVIEW, + SchemaVersionState::CHANGES_REQUIRED, + SchemaVersionState::REVIEWED, + SchemaVersionState::ENABLED, + SchemaVersionState::DISABLED, + SchemaVersionState::ARCHIVED, + SchemaVersionState::DELETED +}; +const char* _kSchemaVersionStateNames[] = { + "INITIATED", + "START_REVIEW", + "CHANGES_REQUIRED", + "REVIEWED", + "ENABLED", + "DISABLED", + "ARCHIVED", + "DELETED" +}; +const std::map<int, const char*> _SchemaVersionState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kSchemaVersionStateValues, _kSchemaVersionStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + int _kFunctionTypeValues[] = { FunctionType::JAVA }; @@ -4009,6 +4075,26 @@ void SerDeInfo::__set_parameters(const std::map<std::string, std::string> & val) this->parameters = val; } +void SerDeInfo::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} + +void SerDeInfo::__set_serializerClass(const std::string& val) { + this->serializerClass = val; +__isset.serializerClass = true; +} + +void SerDeInfo::__set_deserializerClass(const std::string& val) { + this->deserializerClass = val; +__isset.deserializerClass = true; +} + +void SerDeInfo::__set_serdeType(const SerdeType::type val) { + this->serdeType = val; +__isset.serdeType = true; +} + uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -4069,6 +4155,40 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->serializerClass); + this->__isset.serializerClass = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->deserializerClass); + this->__isset.deserializerClass = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast144; + xfer += iprot->readI32(ecast144); + this->serdeType = (SerdeType::type)ecast144; + this->__isset.serdeType = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -4097,16 +4217,36 @@ uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3); { 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 _iter144; - for (_iter144 = this->parameters.begin(); _iter144 != this->parameters.end(); ++_iter144) + std::map<std::string, std::string> ::const_iterator _iter145; + for (_iter145 = this->parameters.begin(); _iter145 != this->parameters.end(); ++_iter145) { - xfer += oprot->writeString(_iter144->first); - xfer += oprot->writeString(_iter144->second); + xfer += oprot->writeString(_iter145->first); + xfer += oprot->writeString(_iter145->second); } xfer += oprot->writeMapEnd(); } xfer += oprot->writeFieldEnd(); + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.serializerClass) { + xfer += oprot->writeFieldBegin("serializerClass", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->serializerClass); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.deserializerClass) { + xfer += oprot->writeFieldBegin("deserializerClass", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->deserializerClass); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.serdeType) { + xfer += oprot->writeFieldBegin("serdeType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32((int32_t)this->serdeType); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -4117,20 +4257,32 @@ void swap(SerDeInfo &a, SerDeInfo &b) { swap(a.name, b.name); swap(a.serializationLib, b.serializationLib); swap(a.parameters, b.parameters); + swap(a.description, b.description); + swap(a.serializerClass, b.serializerClass); + swap(a.deserializerClass, b.deserializerClass); + swap(a.serdeType, b.serdeType); swap(a.__isset, b.__isset); } -SerDeInfo::SerDeInfo(const SerDeInfo& other145) { - name = other145.name; - serializationLib = other145.serializationLib; - parameters = other145.parameters; - __isset = other145.__isset; -} -SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other146) { +SerDeInfo::SerDeInfo(const SerDeInfo& other146) { name = other146.name; serializationLib = other146.serializationLib; parameters = other146.parameters; + description = other146.description; + serializerClass = other146.serializerClass; + deserializerClass = other146.deserializerClass; + serdeType = other146.serdeType; __isset = other146.__isset; +} +SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other147) { + name = other147.name; + serializationLib = other147.serializationLib; + parameters = other147.parameters; + description = other147.description; + serializerClass = other147.serializerClass; + deserializerClass = other147.deserializerClass; + serdeType = other147.serdeType; + __isset = other147.__isset; return *this; } void SerDeInfo::printTo(std::ostream& out) const { @@ -4139,6 +4291,10 @@ void SerDeInfo::printTo(std::ostream& out) const { out << "name=" << to_string(name); out << ", " << "serializationLib=" << to_string(serializationLib); out << ", " << "parameters=" << to_string(parameters); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "<null>")); + out << ", " << "serializerClass="; (__isset.serializerClass ? (out << to_string(serializerClass)) : (out << "<null>")); + out << ", " << "deserializerClass="; (__isset.deserializerClass ? (out << to_string(deserializerClass)) : (out << "<null>")); + out << ", " << "serdeType="; (__isset.serdeType ? (out << to_string(serdeType)) : (out << "<null>")); out << ")"; } @@ -4229,15 +4385,15 @@ void swap(Order &a, Order &b) { swap(a.__isset, b.__isset); } -Order::Order(const Order& other147) { - col = other147.col; - order = other147.order; - __isset = other147.__isset; -} -Order& Order::operator=(const Order& other148) { +Order::Order(const Order& other148) { col = other148.col; order = other148.order; __isset = other148.__isset; +} +Order& Order::operator=(const Order& other149) { + col = other149.col; + order = other149.order; + __isset = other149.__isset; return *this; } void Order::printTo(std::ostream& out) const { @@ -4290,14 +4446,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColNames.clear(); - uint32_t _size149; - ::apache::thrift::protocol::TType _etype152; - xfer += iprot->readListBegin(_etype152, _size149); - this->skewedColNames.resize(_size149); - uint32_t _i153; - for (_i153 = 0; _i153 < _size149; ++_i153) + uint32_t _size150; + ::apache::thrift::protocol::TType _etype153; + xfer += iprot->readListBegin(_etype153, _size150); + this->skewedColNames.resize(_size150); + uint32_t _i154; + for (_i154 = 0; _i154 < _size150; ++_i154) { - xfer += iprot->readString(this->skewedColNames[_i153]); + xfer += iprot->readString(this->skewedColNames[_i154]); } xfer += iprot->readListEnd(); } @@ -4310,23 +4466,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColValues.clear(); - uint32_t _size154; - ::apache::thrift::protocol::TType _etype157; - xfer += iprot->readListBegin(_etype157, _size154); - this->skewedColValues.resize(_size154); - uint32_t _i158; - for (_i158 = 0; _i158 < _size154; ++_i158) + uint32_t _size155; + ::apache::thrift::protocol::TType _etype158; + xfer += iprot->readListBegin(_etype158, _size155); + this->skewedColValues.resize(_size155); + uint32_t _i159; + for (_i159 = 0; _i159 < _size155; ++_i159) { { - this->skewedColValues[_i158].clear(); - uint32_t _size159; - ::apache::thrift::protocol::TType _etype162; - xfer += iprot->readListBegin(_etype162, _size159); - this->skewedColValues[_i158].resize(_size159); - uint32_t _i163; - for (_i163 = 0; _i163 < _size159; ++_i163) + this->skewedColValues[_i159].clear(); + uint32_t _size160; + ::apache::thrift::protocol::TType _etype163; + xfer += iprot->readListBegin(_etype163, _size160); + this->skewedColValues[_i159].resize(_size160); + uint32_t _i164; + for (_i164 = 0; _i164 < _size160; ++_i164) { - xfer += iprot->readString(this->skewedColValues[_i158][_i163]); + xfer += iprot->readString(this->skewedColValues[_i159][_i164]); } xfer += iprot->readListEnd(); } @@ -4342,29 +4498,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->skewedColValueLocationMaps.clear(); - uint32_t _size164; - ::apache::thrift::protocol::TType _ktype165; - ::apache::thrift::protocol::TType _vtype166; - xfer += iprot->readMapBegin(_ktype165, _vtype166, _size164); - uint32_t _i168; - for (_i168 = 0; _i168 < _size164; ++_i168) + uint32_t _size165; + ::apache::thrift::protocol::TType _ktype166; + ::apache::thrift::protocol::TType _vtype167; + xfer += iprot->readMapBegin(_ktype166, _vtype167, _size165); + uint32_t _i169; + for (_i169 = 0; _i169 < _size165; ++_i169) { - std::vector<std::string> _key169; + std::vector<std::string> _key170; { - _key169.clear(); - uint32_t _size171; - ::apache::thrift::protocol::TType _etype174; - xfer += iprot->readListBegin(_etype174, _size171); - _key169.resize(_size171); - uint32_t _i175; - for (_i175 = 0; _i175 < _size171; ++_i175) + _key170.clear(); + uint32_t _size172; + ::apache::thrift::protocol::TType _etype175; + xfer += iprot->readListBegin(_etype175, _size172); + _key170.resize(_size172); + uint32_t _i176; + for (_i176 = 0; _i176 < _size172; ++_i176) { - xfer += iprot->readString(_key169[_i175]); + xfer += iprot->readString(_key170[_i176]); } xfer += iprot->readListEnd(); } - std::string& _val170 = this->skewedColValueLocationMaps[_key169]; - xfer += iprot->readString(_val170); + std::string& _val171 = this->skewedColValueLocationMaps[_key170]; + xfer += iprot->readString(_val171); } xfer += iprot->readMapEnd(); } @@ -4393,10 +4549,10 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColNames.size())); - std::vector<std::string> ::const_iterator _iter176; - for (_iter176 = this->skewedColNames.begin(); _iter176 != this->skewedColNames.end(); ++_iter176) + std::vector<std::string> ::const_iterator _iter177; + for (_iter177 = this->skewedColNames.begin(); _iter177 != this->skewedColNames.end(); ++_iter177) { - xfer += oprot->writeString((*_iter176)); + xfer += oprot->writeString((*_iter177)); } xfer += oprot->writeListEnd(); } @@ -4405,15 +4561,15 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->skewedColValues.size())); - std::vector<std::vector<std::string> > ::const_iterator _iter177; - for (_iter177 = this->skewedColValues.begin(); _iter177 != this->skewedColValues.end(); ++_iter177) + std::vector<std::vector<std::string> > ::const_iterator _iter178; + for (_iter178 = this->skewedColValues.begin(); _iter178 != this->skewedColValues.end(); ++_iter178) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter177).size())); - std::vector<std::string> ::const_iterator _iter178; - for (_iter178 = (*_iter177).begin(); _iter178 != (*_iter177).end(); ++_iter178) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter178).size())); + std::vector<std::string> ::const_iterator _iter179; + for (_iter179 = (*_iter178).begin(); _iter179 != (*_iter178).end(); ++_iter179) { - xfer += oprot->writeString((*_iter178)); + xfer += oprot->writeString((*_iter179)); } xfer += oprot->writeListEnd(); } @@ -4425,19 +4581,19 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColValueLocationMaps.size())); - std::map<std::vector<std::string> , std::string> ::const_iterator _iter179; - for (_iter179 = this->skewedColValueLocationMaps.begin(); _iter179 != this->skewedColValueLocationMaps.end(); ++_iter179) + std::map<std::vector<std::string> , std::string> ::const_iterator _iter180; + for (_iter180 = this->skewedColValueLocationMaps.begin(); _iter180 != this->skewedColValueLocationMaps.end(); ++_iter180) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter179->first.size())); - std::vector<std::string> ::const_iterator _iter180; - for (_iter180 = _iter179->first.begin(); _iter180 != _iter179->first.end(); ++_iter180) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter180->first.size())); + std::vector<std::string> ::const_iterator _iter181; + for (_iter181 = _iter180->first.begin(); _iter181 != _iter180->first.end(); ++_iter181) { - xfer += oprot->writeString((*_iter180)); + xfer += oprot->writeString((*_iter181)); } xfer += oprot->writeListEnd(); } - xfer += oprot->writeString(_iter179->second); + xfer += oprot->writeString(_iter180->second); } xfer += oprot->writeMapEnd(); } @@ -4456,17 +4612,17 @@ void swap(SkewedInfo &a, SkewedInfo &b) { swap(a.__isset, b.__isset); } -SkewedInfo::SkewedInfo(const SkewedInfo& other181) { - skewedColNames = other181.skewedColNames; - skewedColValues = other181.skewedColValues; - skewedColValueLocationMaps = other181.skewedColValueLocationMaps; - __isset = other181.__isset; -} -SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other182) { +SkewedInfo::SkewedInfo(const SkewedInfo& other182) { skewedColNames = other182.skewedColNames; skewedColValues = other182.skewedColValues; skewedColValueLocationMaps = other182.skewedColValueLocationMaps; __isset = other182.__isset; +} +SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other183) { + skewedColNames = other183.skewedColNames; + skewedColValues = other183.skewedColValues; + skewedColValueLocationMaps = other183.skewedColValueLocationMaps; + __isset = other183.__isset; return *this; } void SkewedInfo::printTo(std::ostream& out) const { @@ -4558,14 +4714,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size183; - ::apache::thrift::protocol::TType _etype186; - xfer += iprot->readListBegin(_etype186, _size183); - this->cols.resize(_size183); - uint32_t _i187; - for (_i187 = 0; _i187 < _size183; ++_i187) + uint32_t _size184; + ::apache::thrift::protocol::TType _etype187; + xfer += iprot->readListBegin(_etype187, _size184); + this->cols.resize(_size184); + uint32_t _i188; + for (_i188 = 0; _i188 < _size184; ++_i188) { - xfer += this->cols[_i187].read(iprot); + xfer += this->cols[_i188].read(iprot); } xfer += iprot->readListEnd(); } @@ -4626,14 +4782,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->bucketCols.clear(); - uint32_t _size188; - ::apache::thrift::protocol::TType _etype191; - xfer += iprot->readListBegin(_etype191, _size188); - this->bucketCols.resize(_size188); - uint32_t _i192; - for (_i192 = 0; _i192 < _size188; ++_i192) + uint32_t _size189; + ::apache::thrift::protocol::TType _etype192; + xfer += iprot->readListBegin(_etype192, _size189); + this->bucketCols.resize(_size189); + uint32_t _i193; + for (_i193 = 0; _i193 < _size189; ++_i193) { - xfer += iprot->readString(this->bucketCols[_i192]); + xfer += iprot->readString(this->bucketCols[_i193]); } xfer += iprot->readListEnd(); } @@ -4646,14 +4802,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sortCols.clear(); - uint32_t _size193; - ::apache::thrift::protocol::TType _etype196; - xfer += iprot->readListBegin(_etype196, _size193); - this->sortCols.resize(_size193); - uint32_t _i197; - for (_i197 = 0; _i197 < _size193; ++_i197) + uint32_t _size194; + ::apache::thrift::protocol::TType _etype197; + xfer += iprot->readListBegin(_etype197, _size194); + this->sortCols.resize(_size194); + uint32_t _i198; + for (_i198 = 0; _i198 < _size194; ++_i198) { - xfer += this->sortCols[_i197].read(iprot); + xfer += this->sortCols[_i198].read(iprot); } xfer += iprot->readListEnd(); } @@ -4666,17 +4822,17 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size198; - ::apache::thrift::protocol::TType _ktype199; - ::apache::thrift::protocol::TType _vtype200; - xfer += iprot->readMapBegin(_ktype199, _vtype200, _size198); - uint32_t _i202; - for (_i202 = 0; _i202 < _size198; ++_i202) + uint32_t _size199; + ::apache::thrift::protocol::TType _ktype200; + ::apache::thrift::protocol::TType _vtype201; + xfer += iprot->readMapBegin(_ktype200, _vtype201, _size199); + uint32_t _i203; + for (_i203 = 0; _i203 < _size199; ++_i203) { - std::string _key203; - xfer += iprot->readString(_key203); - std::string& _val204 = this->parameters[_key203]; - xfer += iprot->readString(_val204); + std::string _key204; + xfer += iprot->readString(_key204); + std::string& _val205 = this->parameters[_key204]; + xfer += iprot->readString(_val205); } xfer += iprot->readMapEnd(); } @@ -4721,10 +4877,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->cols.size())); - std::vector<FieldSchema> ::const_iterator _iter205; - for (_iter205 = this->cols.begin(); _iter205 != this->cols.end(); ++_iter205) + std::vector<FieldSchema> ::const_iterator _iter206; + for (_iter206 = this->cols.begin(); _iter206 != this->cols.end(); ++_iter206) { - xfer += (*_iter205).write(oprot); + xfer += (*_iter206).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4757,10 +4913,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->bucketCols.size())); - std::vector<std::string> ::const_iterator _iter206; - for (_iter206 = this->bucketCols.begin(); _iter206 != this->bucketCols.end(); ++_iter206) + std::vector<std::string> ::const_iterator _iter207; + for (_iter207 = this->bucketCols.begin(); _iter207 != this->bucketCols.end(); ++_iter207) { - xfer += oprot->writeString((*_iter206)); + xfer += oprot->writeString((*_iter207)); } xfer += oprot->writeListEnd(); } @@ -4769,10 +4925,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sortCols.size())); - std::vector<Order> ::const_iterator _iter207; - for (_iter207 = this->sortCols.begin(); _iter207 != this->sortCols.end(); ++_iter207) + std::vector<Order> ::const_iterator _iter208; + for (_iter208 = this->sortCols.begin(); _iter208 != this->sortCols.end(); ++_iter208) { - xfer += (*_iter207).write(oprot); + xfer += (*_iter208).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4781,11 +4937,11 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10); { 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 _iter208; - for (_iter208 = this->parameters.begin(); _iter208 != this->parameters.end(); ++_iter208) + std::map<std::string, std::string> ::const_iterator _iter209; + for (_iter209 = this->parameters.begin(); _iter209 != this->parameters.end(); ++_iter209) { - xfer += oprot->writeString(_iter208->first); - xfer += oprot->writeString(_iter208->second); + xfer += oprot->writeString(_iter209->first); + xfer += oprot->writeString(_iter209->second); } xfer += oprot->writeMapEnd(); } @@ -4823,22 +4979,7 @@ void swap(StorageDescriptor &a, StorageDescriptor &b) { swap(a.__isset, b.__isset); } -StorageDescriptor::StorageDescriptor(const StorageDescriptor& other209) { - cols = other209.cols; - location = other209.location; - inputFormat = other209.inputFormat; - outputFormat = other209.outputFormat; - compressed = other209.compressed; - numBuckets = other209.numBuckets; - serdeInfo = other209.serdeInfo; - bucketCols = other209.bucketCols; - sortCols = other209.sortCols; - parameters = other209.parameters; - skewedInfo = other209.skewedInfo; - storedAsSubDirectories = other209.storedAsSubDirectories; - __isset = other209.__isset; -} -StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other210) { +StorageDescriptor::StorageDescriptor(const StorageDescriptor& other210) { cols = other210.cols; location = other210.location; inputFormat = other210.inputFormat; @@ -4852,6 +4993,21 @@ StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other21 skewedInfo = other210.skewedInfo; storedAsSubDirectories = other210.storedAsSubDirectories; __isset = other210.__isset; +} +StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other211) { + cols = other211.cols; + location = other211.location; + inputFormat = other211.inputFormat; + outputFormat = other211.outputFormat; + compressed = other211.compressed; + numBuckets = other211.numBuckets; + serdeInfo = other211.serdeInfo; + bucketCols = other211.bucketCols; + sortCols = other211.sortCols; + parameters = other211.parameters; + skewedInfo = other211.skewedInfo; + storedAsSubDirectories = other211.storedAsSubDirectories; + __isset = other211.__isset; return *this; } void StorageDescriptor::printTo(std::ostream& out) const { @@ -5026,14 +5182,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size211; - ::apache::thrift::protocol::TType _etype214; - xfer += iprot->readListBegin(_etype214, _size211); - this->partitionKeys.resize(_size211); - uint32_t _i215; - for (_i215 = 0; _i215 < _size211; ++_i215) + uint32_t _size212; + ::apache::thrift::protocol::TType _etype215; + xfer += iprot->readListBegin(_etype215, _size212); + this->partitionKeys.resize(_size212); + uint32_t _i216; + for (_i216 = 0; _i216 < _size212; ++_i216) { - xfer += this->partitionKeys[_i215].read(iprot); + xfer += this->partitionKeys[_i216].read(iprot); } xfer += iprot->readListEnd(); } @@ -5046,17 +5202,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size216; - ::apache::thrift::protocol::TType _ktype217; - ::apache::thrift::protocol::TType _vtype218; - xfer += iprot->readMapBegin(_ktype217, _vtype218, _size216); - uint32_t _i220; - for (_i220 = 0; _i220 < _size216; ++_i220) + uint32_t _size217; + ::apache::thrift::protocol::TType _ktype218; + ::apache::thrift::protocol::TType _vtype219; + xfer += iprot->readMapBegin(_ktype218, _vtype219, _size217); + uint32_t _i221; + for (_i221 = 0; _i221 < _size217; ++_i221) { - std::string _key221; - xfer += iprot->readString(_key221); - std::string& _val222 = this->parameters[_key221]; - xfer += iprot->readString(_val222); + std::string _key222; + xfer += iprot->readString(_key222); + std::string& _val223 = this->parameters[_key222]; + xfer += iprot->readString(_val223); } xfer += iprot->readMapEnd(); } @@ -5117,17 +5273,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->creationMetadata.clear(); - uint32_t _size223; - ::apache::thrift::protocol::TType _ktype224; - ::apache::thrift::protocol::TType _vtype225; - xfer += iprot->readMapBegin(_ktype224, _vtype225, _size223); - uint32_t _i227; - for (_i227 = 0; _i227 < _size223; ++_i227) + uint32_t _size224; + ::apache::thrift::protocol::TType _ktype225; + ::apache::thrift::protocol::TType _vtype226; + xfer += iprot->readMapBegin(_ktype225, _vtype226, _size224); + uint32_t _i228; + for (_i228 = 0; _i228 < _size224; ++_i228) { - std::string _key228; - xfer += iprot->readString(_key228); - BasicTxnInfo& _val229 = this->creationMetadata[_key228]; - xfer += _val229.read(iprot); + std::string _key229; + xfer += iprot->readString(_key229); + BasicTxnInfo& _val230 = this->creationMetadata[_key229]; + xfer += _val230.read(iprot); } xfer += iprot->readMapEnd(); } @@ -5184,10 +5340,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 _iter230; - for (_iter230 = this->partitionKeys.begin(); _iter230 != this->partitionKeys.end(); ++_iter230) + std::vector<FieldSchema> ::const_iterator _iter231; + for (_iter231 = this->partitionKeys.begin(); _iter231 != this->partitionKeys.end(); ++_iter231) { - xfer += (*_iter230).write(oprot); + xfer += (*_iter231).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5196,11 +5352,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 _iter231; - for (_iter231 = this->parameters.begin(); _iter231 != this->parameters.end(); ++_iter231) + std::map<std::string, std::string> ::const_iterator _iter232; + for (_iter232 = this->parameters.begin(); _iter232 != this->parameters.end(); ++_iter232) { - xfer += oprot->writeString(_iter231->first); - xfer += oprot->writeString(_iter231->second); + xfer += oprot->writeString(_iter232->first); + xfer += oprot->writeString(_iter232->second); } xfer += oprot->writeMapEnd(); } @@ -5237,11 +5393,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("creationMetadata", ::apache::thrift::protocol::T_MAP, 16); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->creationMetadata.size())); - std::map<std::string, BasicTxnInfo> ::const_iterator _iter232; - for (_iter232 = this->creationMetadata.begin(); _iter232 != this->creationMetadata.end(); ++_iter232) + std::map<std::string, BasicTxnInfo> ::const_iterator _iter233; + for (_iter233 = this->creationMetadata.begin(); _iter233 != this->creationMetadata.end(); ++_iter233) { - xfer += oprot->writeString(_iter232->first); - xfer += _iter232->second.write(oprot); + xfer += oprot->writeString(_iter233->first); + xfer += _iter233->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -5273,26 +5429,7 @@ void swap(Table &a, Table &b) { swap(a.__isset, b.__isset); } -Table::Table(const Table& other233) { - tableName = other233.tableName; - dbName = other233.dbName; - owner = other233.owner; - createTime = other233.createTime; - lastAccessTime = other233.lastAccessTime; - retention = other233.retention; - sd = other233.sd; - partitionKeys = other233.partitionKeys; - parameters = other233.parameters; - viewOriginalText = other233.viewOriginalText; - viewExpandedText = other233.viewExpandedText; - tableType = other233.tableType; - privileges = other233.privileges; - temporary = other233.temporary; - rewriteEnabled = other233.rewriteEnabled; - creationMetadata = other233.creationMetadata; - __isset = other233.__isset; -} -Table& Table::operator=(const Table& other234) { +Table::Table(const Table& other234) { tableName = other234.tableName; dbName = other234.dbName; owner = other234.owner; @@ -5310,6 +5447,25 @@ Table& Table::operator=(const Table& other234) { rewriteEnabled = other234.rewriteEnabled; creationMetadata = other234.creationMetadata; __isset = other234.__isset; +} +Table& Table::operator=(const Table& other235) { + tableName = other235.tableName; + dbName = other235.dbName; + owner = other235.owner; + createTime = other235.createTime; + lastAccessTime = other235.lastAccessTime; + retention = other235.retention; + sd = other235.sd; + partitionKeys = other235.partitionKeys; + parameters = other235.parameters; + viewOriginalText = other235.viewOriginalText; + viewExpandedText = other235.viewExpandedText; + tableType = other235.tableType; + privileges = other235.privileges; + temporary = other235.temporary; + rewriteEnabled = other235.rewriteEnabled; + creationMetadata = other235.creationMetadata; + __isset = other235.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -5397,14 +5553,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size235; - ::apache::thrift::protocol::TType _etype238; - xfer += iprot->readListBegin(_etype238, _size235); - this->values.resize(_size235); - uint32_t _i239; - for (_i239 = 0; _i239 < _size235; ++_i239) + uint32_t _size236; + ::apache::thrift::protocol::TType _etype239; + xfer += iprot->readListBegin(_etype239, _size236); + this->values.resize(_size236); + uint32_t _i240; + for (_i240 = 0; _i240 < _size236; ++_i240) { - xfer += iprot->readString(this->values[_i239]); + xfer += iprot->readString(this->values[_i240]); } xfer += iprot->readListEnd(); } @@ -5457,17 +5613,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size240; - ::apache::thrift::protocol::TType _ktype241; - ::apache::thrift::protocol::TType _vtype242; - xfer += iprot->readMapBegin(_ktype241, _vtype242, _size240); - uint32_t _i244; - for (_i244 = 0; _i244 < _size240; ++_i244) + uint32_t _size241; + ::apache::thrift::protocol::TType _ktype242; + ::apache::thrift::protocol::TType _vtype243; + xfer += iprot->readMapBegin(_ktype242, _vtype243, _size241); + uint32_t _i245; + for (_i245 = 0; _i245 < _size241; ++_i245) { - std::string _key245; - xfer += iprot->readString(_key245); - std::string& _val246 = this->parameters[_key245]; - xfer += iprot->readString(_val246); + std::string _key246; + xfer += iprot->readString(_key246); + std::string& _val247 = this->parameters[_key246]; + xfer += iprot->readString(_val247); } xfer += iprot->readMapEnd(); } @@ -5504,10 +5660,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 _iter247; - for (_iter247 = this->values.begin(); _iter247 != this->values.end(); ++_iter247) + std::vector<std::string> ::const_iterator _iter248; + for (_iter248 = this->values.begin(); _iter248 != this->values.end(); ++_iter248) { - xfer += oprot->writeString((*_iter247)); + xfer += oprot->writeString((*_iter248)); } xfer += oprot->writeListEnd(); } @@ -5536,11 +5692,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 _iter248; - for (_iter248 = this->parameters.begin(); _iter248 != this->parameters.end(); ++_iter248) + std::map<std::string, std::string> ::const_iterator _iter249; + for (_iter249 = this->parameters.begin(); _iter249 != this->parameters.end(); ++_iter249) { - xfer += oprot->writeString(_iter248->first); - xfer += oprot->writeString(_iter248->second); + xfer += oprot->writeString(_iter249->first); + xfer += oprot->writeString(_iter249->second); } xfer += oprot->writeMapEnd(); } @@ -5569,18 +5725,7 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other249) { - values = other249.values; - dbName = other249.dbName; - tableName = other249.tableName; - createTime = other249.createTime; - lastAccessTime = other249.lastAccessTime; - sd = other249.sd; - parameters = other249.parameters; - privileges = other249.privileges; - __isset = other249.__isset; -} -Partition& Partition::operator=(const Partition& other250) { +Partition::Partition(const Partition& other250) { values = other250.values; dbName = other250.dbName; tableName = other250.tableName; @@ -5590,6 +5735,17 @@ Partition& Partition::operator=(const Partition& other250) { parameters = other250.parameters; privileges = other250.privileges; __isset = other250.__isset; +} +Partition& Partition::operator=(const Partition& other251) { + values = other251.values; + dbName = other251.dbName; + tableName = other251.tableName; + createTime = other251.createTime; + lastAccessTime = other251.lastAccessTime; + sd = other251.sd; + parameters = other251.parameters; + privileges = other251.privileges; + __isset = other251.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -5661,14 +5817,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - 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) + uint32_t _size252; + ::apache::thrift::protocol::TType _etype255; + xfer += iprot->readListBegin(_etype255, _size252); + this->values.resize(_size252); + uint32_t _i256; + for (_i256 = 0; _i256 < _size252; ++_i256) { - xfer += iprot->readString(this->values[_i255]); + xfer += iprot->readString(this->values[_i256]); } xfer += iprot->readListEnd(); } @@ -5705,17 +5861,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - 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) + uint32_t _size257; + ::apache::thrift::protocol::TType _ktype258; + ::apache::thrift::protocol::TType _vtype259; + xfer += iprot->readMapBegin(_ktype258, _vtype259, _size257); + uint32_t _i261; + for (_i261 = 0; _i261 < _size257; ++_i261) { - std::string _key261; - xfer += iprot->readString(_key261); - std::string& _val262 = this->parameters[_key261]; - xfer += iprot->readString(_val262); + std::string _key262; + xfer += iprot->readString(_key262); + std::string& _val263 = this->parameters[_key262]; + xfer += iprot->readString(_val263); } xfer += iprot->readMapEnd(); } @@ -5752,10 +5908,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 _iter263; - for (_iter263 = this->values.begin(); _iter263 != this->values.end(); ++_iter263) + std::vector<std::string> ::const_iterator _iter264; + for (_iter264 = this->values.begin(); _iter264 != this->values.end(); ++_iter264) { - xfer += oprot->writeString((*_iter263)); + xfer += oprot->writeString((*_iter264)); } xfer += oprot->writeListEnd(); } @@ -5776,11 +5932,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 _iter264; - for (_iter264 = this->parameters.begin(); _iter264 != this->parameters.end(); ++_iter264) + std::map<std::string, std::string> ::const_iterator _iter265; + for (_iter265 = this->parameters.begin(); _iter265 != this->parameters.end(); ++_iter265) { - xfer += oprot->writeString(_iter264->first); - xfer += oprot->writeString(_iter264->second); + xfer += oprot->writeString(_iter265->first); + xfer += oprot->writeString(_iter265->second); } xfer += oprot->writeMapEnd(); } @@ -5807,16 +5963,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other265) { - values = other265.values; - createTime = other265.createTime; - lastAccessTime = other265.lastAccessTime; - relativePath = other265.relativePath; - parameters = other265.parameters; - privileges = other265.privileges; - __isset = other265.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other266) { +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other266) { values = other266.values; createTime = other266.createTime; lastAccessTime = other266.lastAccessTime; @@ -5824,6 +5971,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe parameters = other266.parameters; privileges = other266.privileges; __isset = other266.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other267) { + values = other267.values; + createTime = other267.createTime; + lastAccessTime = other267.lastAccessTime; + relativePath = other267.relativePath; + parameters = other267.parameters; + privileges = other267.privileges; + __isset = other267.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -5876,14 +6032,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size267; - ::apache::thrift::protocol::TType _etype270; - xfer += iprot->readListBegin(_etype270, _size267); - this->partitions.resize(_size267); - uint32_t _i271; - for (_i271 = 0; _i271 < _size267; ++_i271) + uint32_t _size268; + ::apache::thrift::protocol::TType _etype271; + xfer += iprot->readListBegin(_etype271, _size268); + this->partitions.resize(_size268); + uint32_t _i272; + for (_i272 = 0; _i272 < _size268; ++_i272) { - xfer += this->partitions[_i271].read(iprot); + xfer += this->partitions[_i272].read(iprot); } xfer += iprot->readListEnd(); } @@ -5920,10 +6076,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 _iter272; - for (_iter272 = this->partitions.begin(); _iter272 != this->partitions.end(); ++_iter272) + std::vector<PartitionWithoutSD> ::const_iterator _iter273; + for (_iter273 = this->partitions.begin(); _iter273 != this->partitions.end(); ++_iter273) { - xfer += (*_iter272).write(oprot); + xfer += (*_iter273).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5945,15 +6101,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other273) { - partitions = other273.partitions; - sd = other273.sd; - __isset = other273.__isset; -} -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other274) { +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other274) { partitions = other274.partitions; sd = other274.sd; __isset = other274.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other275) { + partitions = other275.partitions; + sd = other275.sd; + __isset = other275.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -5998,14 +6154,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size275; - ::apache::thrift::protocol::TType _etype278; - xfer += iprot->readListBegin(_etype278, _size275); - this->partitions.resize(_size275); - uint32_t _i279; - for (_i279 = 0; _i279 < _size275; ++_i279) + uint32_t _size276; + ::apache::thrift::protocol::TType _etype279; + xfer += iprot->readListBegin(_etype279, _size276); + this->partitions.resize(_size276); + uint32_t _i280; + for (_i280 = 0; _i280 < _size276; ++_i280) { - xfer += this->partitions[_i279].read(iprot); + xfer += this->partitions[_i280].read(iprot); } xfer += iprot->readListEnd(); } @@ -6034,10 +6190,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 _iter280; - for (_iter280 = this->partitions.begin(); _iter280 != this->partitions.end(); ++_iter280) + std::vector<Partition> ::const_iterator _iter281; + for (_iter281 = this->partitions.begin(); _iter281 != this->partitions.end(); ++_iter281) { - xfer += (*_iter280).write(oprot); + xfer += (*_iter281).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6054,13 +6210,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other281) { - partitions = other281.partitions; - __isset = other281.__isset; -} -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other282) { +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other282) { partitions = other282.partitions; __isset = other282.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other283) { + partitions = other283.partitions; + __isset = other283.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -6212,21 +6368,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other283) { - dbName = other283.dbName; - tableName = other283.tableName; - rootPath = other283.rootPath; - sharedSDPartitionSpec = other283.sharedSDPartitionSpec; - partitionList = other283.partitionList; - __isset = other283.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other284) { +PartitionSpec::PartitionSpec(const PartitionSpec& other284) { dbName = other284.dbName; tableName = other284.tableName; rootPath = other284.rootPath; sharedSDPartitionSpec = other284.sharedSDPartitionSpec; partitionList = other284.partitionList; __isset = other284.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other285) { + dbName = other285.dbName; + tableName = other285.tableName; + rootPath = other285.rootPath; + sharedSDPartitionSpec = other285.sharedSDPartitionSpec; + partitionList = other285.partitionList; + __isset = other285.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -6374,17 +6530,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size285; - ::apache::thrift::protocol::TType _ktype286; - ::apache::thrift::protocol::TType _vtype287; - xfer += iprot->readMapBegin(_ktype286, _vtype287, _size285); - uint32_t _i289; - for (_i289 = 0; _i289 < _size285; ++_i289) + uint32_t _size286; + ::apache::thrift::protocol::TType _ktype287; + ::apache::thrift::protocol::TType _vtype288; + xfer += iprot->readMapBegin(_ktype287, _vtype288, _size286); + uint32_t _i290; + for (_i290 = 0; _i290 < _size286; ++_i290) { - std::string _key290; - xfer += iprot->readString(_key290); - std::string& _val291 = this->parameters[_key290]; - xfer += iprot->readString(_val291); + std::string _key291; + xfer += iprot->readString(_key291); + std::string& _val292 = this->parameters[_key291]; + xfer += iprot->readString(_val292); } xfer += iprot->readMapEnd(); } @@ -6453,11 +6609,11 @@ uint32_t Index::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 _iter292; - for (_iter292 = this->parameters.begin(); _iter292 != this->parameters.end(); ++_iter292) + std::map<std::string, std::string> ::const_iterator _iter293; + for (_iter293 = this->parameters.begin(); _iter293 != this->parameters.end(); ++_iter293) { - xfer += oprot->writeString(_iter292->first); - xfer += oprot->writeString(_iter292->second); + xfer += oprot->writeString(_iter293->first); + xfer += oprot->writeString(_iter293->second); } xfer += oprot->writeMapEnd(); } @@ -6487,20 +6643,7 @@ void swap(Index &a, Index &b) { swap(a.__isset, b.__isset); } -Index::Index(const Index& other293) { - indexName = other293.indexName; - indexHandlerClass = other293.indexHandlerClass; - dbName = other293.dbName; - origTableName = other293.origTableName; - createTime = other293.createTime; - lastAccessTime = other293.lastAccessTime; - indexTableName = other293.indexTableName; - sd = other293.sd; - parameters = other293.parameters; - deferredRebuild = other293.deferredRebuild; - __isset = other293.__isset; -} -Index& Index::operator=(const Index& other294) { +Index::Index(const Index& other294) { indexName = other294.indexName; indexHandlerClass = other294.indexHandlerClass; dbName = other294.dbName; @@ -6512,6 +6655,19 @@ Index& Index::operator=(const Index& other294) { parameters = other294.parameters; deferredRebuild = other294.deferredRebuild; __isset = other294.__isset; +} +Index& Index::operator=(const Index& other295) { + indexName = other295.indexName; + indexHandlerClass = other295.indexHandlerClass; + dbName = other295.dbName; + origTableName = other295.origTableName; + createTime = other295.createTime; + lastAccessTime = other295.lastAccessTime; + indexTableName = other295.indexTableName; + sd = other295.sd; + parameters = other295.parameters; + deferredRebuild = other295.deferredRebuild; + __isset = other295.__isset; return *this; } void Index::printTo(std::ostream& out) const { @@ -6662,19 +6818,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other295) { - numTrues = other295.numTrues; - numFalses = other295.numFalses; - numNulls = other295.numNulls; - bitVectors = other295.bitVectors; - __isset = other295.__isset; -} -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other296) { +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other296) { numTrues = other296.numTrues; numFalses = other296.numFalses; numNulls = other296.numNulls; bitVectors = other296.bitVectors; __isset = other296.__isset; +} +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other297) { + numTrues = other297.numTrues; + numFalses = other297.numFalses; + numNulls = other297.numNulls; + bitVectors = other297.bitVectors; + __isset = other297.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -6837,21 +6993,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other297) { - lowValue = other297.lowValue; - highValue = other297.highValue; - numNulls = other297.numNulls; - numDVs = other297.numDVs; - bitVectors = other297.bitVectors; - __isset = other297.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other298) { +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other298) { lowValue = other298.lowValue; highValue = other298.highValue; numNulls = other298.numNulls; numDVs = other298.numDVs; bitVectors = other298.bitVectors; __isset = other298.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other299) { + lowValue = other299.lowValue; + highValue = other299.highValue; + numNulls = other299.numNulls; + numDVs = other299.numDVs; + bitVectors = other299.bitVectors; + __isset = other299.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -7015,21 +7171,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other299) { - lowValue = other299.lowValue; - highValue = other299.highValue; - numNulls = other299.numNulls; - numDVs = other299.numDVs; - bitVectors = other299.bitVectors; - __isset = other299.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other300) { +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other300) { lowValue = other300.lowValue; highValue = other300.highValue; numNulls = other300.numNulls; numDVs = other300.numDVs; bitVectors = other300.bitVectors; __isset = other300.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other301) { + lowValue = other301.lowValue; + highValue = other301.highValue; + numNulls = other301.numNulls; + numDVs = other301.numDVs; + bitVectors = other301.bitVectors; + __isset = other301.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -7195,21 +7351,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other301) { - maxColLen = other301.maxColLen; - avgColLen = other301.avgColLen; - numNulls = other301.numNulls; - numDVs = other301.numDVs; - bitVectors = other301.bitVectors; - __isset = other301.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other302) { +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other302) { maxColLen = other302.maxColLen; avgColLen = other302.avgColLen; numNulls = other302.numNulls; numDVs = other302.numDVs; bitVectors = other302.bitVectors; __isset = other302.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other303) { + maxColLen = other303.maxColLen; + avgColLen = other303.avgColLen; + numNulls = other303.numNulls; + numDVs = other303.numDVs; + bitVectors = other303.bitVectors; + __isset = other303.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -7355,19 +7511,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other303) { - maxColLen = other303.maxColLen; - avgColLen = other303.avgColLen; - numNulls = other303.numNulls; - bitVectors = other303.bitVectors; - __isset = other303.__isset; -} -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other304) { +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other304) { maxColLen = other304.maxColLen; avgColLen = other304.avgColLen; numNulls = other304.numNulls; bitVectors = other304.bitVectors; __isset = other304.__isset; +} +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other305) { + maxColLen = other305.maxColLen; + avgColLen = other305.avgColLen; + numNulls = other305.numNulls; + bitVectors = other305.bitVectors; + __isset = other305.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -7472,13 +7628,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other305) { - unscaled = other305.unscaled; - scale = other305.scale; -} -Decimal& Decimal::operator=(const Decimal& other306) { +Decimal::Decimal(const Decimal& other306) { unscaled = other306.unscaled; scale = other306.scale; +} +Decimal& Decimal::operator=(const Decimal& other307) { + unscaled = other307.unscaled; + scale = other307.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7639,21 +7795,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other307) { - lowValue = other307.lowValue; - highValue = other307.highValue; - numNulls = other307.numNulls; - numDVs = other307.numDVs; - bitVectors = other307.bitVectors; - __isset = other307.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other308) { +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other308) { lowValue = other308.lowValue; highValue = other308.highValue; numNulls = other308.numNulls; numDVs = other308.numDVs; bitVectors = other308.bitVectors; __isset = other308.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other309) { + lowValue = other309.lowValue; + highValue = other309.highValue; + numNulls = other309.numNulls; + numDVs = other309.numDVs; + bitVectors = other309.bitVectors; + __isset = other309.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7739,11 +7895,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other309) { - daysSinceEpoch = other309.daysSinceEpoch; -} -Date& Date::operator=(const Date& other310) { +Date::Date(const Date& other310) { daysSinceEpoch = other310.daysSinceEpoch; +} +Date& Date::operator=(const Date& other311) { + daysSinceEpoch = other311.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7903,21 +8059,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other311) { - lowValue = other311.lowValue; - highValue = other311.highValue; - numNulls = other311.numNulls; - numDVs = other311.numDVs; - bitVectors = other311.bitVectors; - __isset = other311.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other312) { +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other312) { lowValue = other312.lowValue; highValue = other312.highValue; numNulls = other312.numNulls; numDVs = other312.numDVs; bitVectors = other312.bitVectors; __isset = other312.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other313) { + lowValue = other313.lowValue; + highValue = other313.highValue; + numNulls = other313.numNulls; + numDVs = other313.numDVs; + bitVectors = other313.bitVectors; + __isset = other313.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -8103,17 +8259,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other313) { - booleanStats = other313.booleanStats; - longStats = other313.longStats; - doubleStats = other313.doubleStats; - stringStats = other313.stringStats; - binaryStats = other313.binaryStats; - decimalStats = other313.decimalStats; - dateStats = other313.dateStats; - __isset = other313.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other314) { +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other314) { booleanStats = other314.booleanStats; longStats = other314.longStats; doubleStats = other314.doubleStats; @@ -8122,6 +8268,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData decimalStats = other314.decimalStats; dateStats = other314.dateStats; __isset = other314.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other315) { + booleanStats = other315.booleanStats; + longStats = other315.longStats; + doubleStats = other315.doubleStats; + stringStats = other315.stringStats; + binaryStats = other315.binaryStats; + decimalStats = other315.decimalStats; + dateStats = other315.dateStats; + __isset = other315.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -8249,15 +8405,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other315) { - colName = other315.colName; - colType = other315.colType; - statsData = other315.statsData; -} -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other316) { +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other316) { colName = other316.colName; colType = other316.colType; statsData = other316.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other317) { + colName = other317.colName; + colType = other317.colType; + statsData = other317.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -8420,21 +8576,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other317) { - isTblLevel = other317.isTblLevel; - dbName = other317.dbName; - tableName = other317.tableName; - partName = other317.partName; - lastAnalyzed = other317.lastAnalyzed; - __isset = other317.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other318) { +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other318) { isTblLevel = other318.isTblLevel; dbName = other318.dbName; tableName = other318.tableName; partName = other318.partName; lastAnalyzed = other318.lastAnalyzed; __isset = other318.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other319) { + isTblLevel = other319.isTblLevel; + dbName = other319.dbName; + tableName = other319.tableName; + partName = other319.partName; + lastAnalyzed = other319.lastAnalyzed; + __isset = other319.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -8496,14 +8652,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size319; - ::apache::thrift::protocol::TType _etype322; - xfer += iprot->readListBegin(_etype322, _size319); - this->statsObj.resize(_size319); - uint32_t _i323; - for (_i323 = 0; _i323 < _size319; ++_i323) + uint32_t _size320; + ::apache::thrift::protocol::TType _etype323; + xfer += iprot->readListBegin(_etype323, _size320); + this->statsObj.resize(_size320); + uint32_t _i324; + for (_i324 = 0; _i324 < _size320; ++_i324) { - xfer += this->statsObj[_i323].read(iprot); + xfer += this->statsObj[_i324].read(iprot); } xfer += iprot->readListEnd(); } @@ -8540,10 +8696,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 _iter324; - for (_iter324 = this->statsObj.begin(); _iter324 != this->statsObj.end(); ++_iter324) + std::vector<ColumnStatisticsObj> ::const_iterator _iter325; + for (_iter325 = this->statsObj.begin(); _iter325 != this->statsObj.end(); ++_iter325) { - xfer += (*_iter324).write(oprot); + xfer += (*_iter325).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8560,13 +8716,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other325) { - statsDesc = other325.statsDesc; - statsObj = other325.statsObj; -} -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other326) { +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other326) { statsDesc = other326.statsDesc; statsObj = other326.statsObj; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other327) { + statsDesc = other327.statsDesc; + statsObj = other327.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8617,14 +8773,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size327; - ::apache::thrift::protocol::TType _etype330; - xfer += iprot->readListBegin(_etype330, _size327); - this->colStats.resize(_size327); - uint32_t _i331; - for (_i331 = 0; _i331 < _size327; ++_i331) + uint32_t _size328; + ::apache::thrift::protocol::TType _etype331; + xfer += iprot->readListBegin(_etype331, _size328); + this->colStats.resize(_size328); + uint32_t _i332; + for (_i332 = 0; _i332 < _size328; ++_i332) { - xfer += this->colStats[_i331].read(iprot); + xfer += this->colStats[_i332].read(iprot); } xfer += iprot->readListEnd(); } @@ -8665,10 +8821,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 _iter332; - for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); ++_iter332) + std::vector<ColumnStatisticsObj> ::const_iterator _iter333; + for (_iter333 = this->colStats.begin(); _iter333 != this->colStats.end(); ++_iter333) { - xfer += (*_iter332).write(oprot); + xfer += (*_iter333).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8689,13 +8845,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other333) { - colStats = other333.colStats; - partsFound = other333.partsFound; -} -AggrStats& AggrStats::operator=(const AggrStats& other334) { +AggrStats::AggrStats(const AggrStats& other334) { colStats = other334.colStats; partsFound = other334.partsFound; +} +AggrStats& AggrStats::operator=(const AggrStats& other335) { + colStats = other335.colStats; + partsFound = other335.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8746,14 +8902,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size335; - ::apache::thrift::protocol::TType _etype338; - xfer += iprot->readListBegin(_etype338, _size335); - this->colStats.resize(_size335); - uint32_t _i339; - for (_i339 = 0; _i339 < _size335; ++_i339) + uint32_t _size336; + ::apache::thrift::protocol::TType _etype339; + xfer += iprot->readListBegin(_etype339, _size336); + this->colStats.resize(_size336); + uint32_t _i340; + for (_i340 = 0; _i340 < _size336; ++_i340) { - xfer += this->colStats[_i339].read(iprot); + xfer += this->colStats[_i340].read(iprot); } xfer += iprot->readListEnd(); } @@ -8792,10 +8948,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 _iter340; - for (_iter340 = this->colStats.begin(); _iter340 != this->colStats.end(); ++_iter340) + std::vector<ColumnStatistics> ::const_iterator _iter341; + for (_iter341 = this->colStats.begin(); _iter341 != this->colStats.end(); ++_iter341) { - xfer += (*_iter340).write(oprot); + xfer += (*_iter341).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8818,15 +8974,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other341) { - colStats = other341.colStats; - needMerge = other341.needMerge; - __isset = other341.__isset; -} -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other342) { +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other342) { colStats = other342.colStats; needMerge = other342.needMerge; __isset = other342.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other343) { + colStats = other343.colStats; + needMerge = other343.needMerge; + __isset = other343.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -8875,14 +9031,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size343; - ::apache::thrift::protocol::TType _etype346; - xfer += iprot->readListBegin(_etype346, _size343); - this->fieldSchemas.resize(_size343); - uint32_t _i347; - for (_i347 = 0; _i347 < _size343; ++_i347) + uint32_t _size344; + ::apache::thrift::protocol::TType _etype347; + xfer += iprot->readListBegin(_etype347, _size344); + this->fieldSchemas.resize(_size344); + uint32_t _i348; + for (_i348 = 0; _i348 < _size344; ++_i348) { - xfer += this->fieldSchemas[_i347].read(iprot); + xfer += this->fieldSchemas[_i348].read(iprot); } xfer += iprot->readListEnd(); } @@ -8895,17 +9051,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size348; - ::apache::thrift::protocol::TType _ktype349; - ::apache::thrift::protocol::TType _vtype350; - xfer += iprot->readMapBegin(_ktype349, _vtype350, _size348); - uint32_t _i352; - for (_i352 = 0; _i352 < _size348; ++_i352) + uint32_t _size349; + ::apache::thrift::protocol::TType _ktype350; + ::apache::thrift::protocol::TType _vtype351; + xfer += iprot->readMapBegin(_ktype350, _vtype351, _size349); + uint32_t _i353; + for (_i353 = 0; _i353 < _size349; ++_i353) { - std::string _key353; - xfer += iprot->readString(_key353); - std::string& _val354 = this->properties[_key353]; - xfer += iprot->readString(_val354); + std::string _key354; + xfer += iprot->readString(_key354); + std::string& _val355 = this->properties[_key354]; + xfer += iprot->readString(_val355); } xfer += iprot->readMapEnd(); } @@ -8934,10 +9090,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 _iter355; - for (_iter355 = this->fieldSchemas.begin(); _iter355 != this->fieldSchemas.end(); ++_iter355) + std::vector<FieldSchema> ::const_iterator _iter356; + for (_iter356 = this->fieldSchemas.begin(); _iter356 != this->fieldSchemas.end(); ++_iter356) { - xfer += (*_iter355).write(oprot); + xfer += (*_iter356).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8946,11 +9102,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 _iter356; - for (_iter356 = this->properties.begin(); _iter356 != this->properties.end(); ++_iter356) + std::map<std::string, std::string> ::const_iterator _iter357; + for (_iter357 = this->properties.begin(); _iter357 != this->properties.end(); ++_iter357) { - xfer += oprot->writeString(_iter356->first); - xfer += oprot->writeString(_iter356->second); + xfer += oprot->writeString(_iter357->first); + xfer += oprot->writeString(_iter357->second); } xfer += oprot->writeMapEnd(); } @@ -8968,15 +9124,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other357) { - fieldSchemas = other357.fieldSchemas; - properties = other357.properties; - __isset = other357.__isset; -} -Schema& Schema::operator=(const Schema& other358) { +Schema::Schema(const Schema& other358) { fieldSchemas = other358.fieldSchemas; properties = other358.properties; __isset = other358.__isset; +} +Schema& Schema::operator=(const Schema& other359) { + fieldSchemas = other359.fieldSchemas; + properties = other359.properties; + __isset = other359.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -9021,17 +9177,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size359; - ::apache::thrift::protocol::TType _ktype360; - ::apache::thrift::protocol::TType _vtype361; - xfer += iprot->readMapBegin(_ktype360, _vtype361, _size359); - uint32_t _i363; - for (_i363 = 0; _i363 < _size359; ++_i363) + uint32_t _size360; + ::apache::thrift::protocol::TType _ktype361; + ::apache::thrift::protocol::TType _vtype362; + xfer += iprot->readMapBegin(_ktype361, _vtype362, _size360); + uint32_t _i364; + for (_i364 = 0; _i364 < _size360; ++_i364) { - std::string _key364; - xfer += iprot->readString(_key364); - std::string& _val365 = this->properties[_key364]; - xfer += iprot->readString(_val365); + std::string _key365; + xfer += iprot->readString(_key365); + std::string& _val366 = this->properties[_key365]; + xfer += iprot->readString(_val366); } xfer += iprot->readMapEnd(); } @@ -9060,11 +9216,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 _iter366; - for (_iter366 = this->properties.begin(); _iter366 != this->properties.end(); ++_iter366) + std::map<std::string, std::string> ::const_iterator _iter367; + for (_iter367 = this->properties.begin(); _iter367 != this->properties.end(); ++_iter367) { - xfer += oprot->writeString(_iter366->first); - xfer += oprot->writeString(_iter366->second); + xfer += oprot->writeString(_iter367->first); + xfer += oprot->writeString(_iter367->second); } xfer += oprot->writeMapEnd(); } @@ -9081,13 +9237,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other367) { - properties = other367.properties; - __isset = other367.__isset; -} -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other368) { +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other368) { properties = other368.properties; __isset = other368.__isset; +} +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other369) { + properties = other369.properties; + __isset = other369.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -9189,13 +9345,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other369) { - db_name = other369.db_name; - tbl_name = other369.tbl_name; -} -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other370) { +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other370) { db_name = other370.db_name; tbl_name = other370.tbl_name; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other371) { + db_name = other371.db_name; + tbl_name = other371.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -9241,14 +9397,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size371; - ::apache::thrift::protocol::TType _etype374; - xfer += iprot->readListBegin(_etype374, _size371); - this->primaryKeys.resize(_size371); - uint32_t _i375; - for (_i375 = 0; _i375 < _size371; ++_i375) + uint32_t _size372; + ::apache::thrift::protocol::TType _etype375; + xfer += iprot->readListBegin(_etype375, _size372); + this->primaryKeys.resize(_size372); + uint32_t _i376; + for (_i376 = 0; _i376 < _size372; ++_i376) { - xfer += this->primaryKeys[_i375].read(iprot); + xfer += this->primaryKeys[_i376].read(iprot); } xfer += iprot->readListEnd(); } @@ -9279,10 +9435,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 _iter376; - for (_iter376 = this->primaryKeys.begin(); _iter376 != this->primaryKeys.end(); ++_iter376) + std::vector<SQLPrimaryKey> ::const_iterator _iter377; + for (_iter377 = this->primaryKeys.begin(); _iter377 != this->primaryKeys.end(); ++_iter377) { - xfer += (*_iter376).write(oprot); + xfer += (*_iter377).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9298,11 +9454,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other377) { - primaryKeys = other377.primaryKeys; -} -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other378) { +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other378) { primaryKeys = other378.primaryKeys; +} +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other379) { + primaryKeys = other379.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -9433,19 +9589,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b)
<TRUNCATED>
