http://git-wip-us.apache.org/repos/asf/hive/blob/a9e1acaf/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 aadf8f1..ed0f068 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(); } @@ -5169,10 +5325,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 _iter223; - for (_iter223 = this->partitionKeys.begin(); _iter223 != this->partitionKeys.end(); ++_iter223) + std::vector<FieldSchema> ::const_iterator _iter224; + for (_iter224 = this->partitionKeys.begin(); _iter224 != this->partitionKeys.end(); ++_iter224) { - xfer += (*_iter223).write(oprot); + xfer += (*_iter224).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5181,11 +5337,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 _iter224; - for (_iter224 = this->parameters.begin(); _iter224 != this->parameters.end(); ++_iter224) + std::map<std::string, std::string> ::const_iterator _iter225; + for (_iter225 = this->parameters.begin(); _iter225 != this->parameters.end(); ++_iter225) { - xfer += oprot->writeString(_iter224->first); - xfer += oprot->writeString(_iter224->second); + xfer += oprot->writeString(_iter225->first); + xfer += oprot->writeString(_iter225->second); } xfer += oprot->writeMapEnd(); } @@ -5249,26 +5405,7 @@ void swap(Table &a, Table &b) { swap(a.__isset, b.__isset); } -Table::Table(const Table& other225) { - tableName = other225.tableName; - dbName = other225.dbName; - owner = other225.owner; - createTime = other225.createTime; - lastAccessTime = other225.lastAccessTime; - retention = other225.retention; - sd = other225.sd; - partitionKeys = other225.partitionKeys; - parameters = other225.parameters; - viewOriginalText = other225.viewOriginalText; - viewExpandedText = other225.viewExpandedText; - tableType = other225.tableType; - privileges = other225.privileges; - temporary = other225.temporary; - rewriteEnabled = other225.rewriteEnabled; - creationMetadata = other225.creationMetadata; - __isset = other225.__isset; -} -Table& Table::operator=(const Table& other226) { +Table::Table(const Table& other226) { tableName = other226.tableName; dbName = other226.dbName; owner = other226.owner; @@ -5286,6 +5423,25 @@ Table& Table::operator=(const Table& other226) { rewriteEnabled = other226.rewriteEnabled; creationMetadata = other226.creationMetadata; __isset = other226.__isset; +} +Table& Table::operator=(const Table& other227) { + tableName = other227.tableName; + dbName = other227.dbName; + owner = other227.owner; + createTime = other227.createTime; + lastAccessTime = other227.lastAccessTime; + retention = other227.retention; + sd = other227.sd; + partitionKeys = other227.partitionKeys; + parameters = other227.parameters; + viewOriginalText = other227.viewOriginalText; + viewExpandedText = other227.viewExpandedText; + tableType = other227.tableType; + privileges = other227.privileges; + temporary = other227.temporary; + rewriteEnabled = other227.rewriteEnabled; + creationMetadata = other227.creationMetadata; + __isset = other227.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -5373,14 +5529,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size227; - ::apache::thrift::protocol::TType _etype230; - xfer += iprot->readListBegin(_etype230, _size227); - this->values.resize(_size227); - uint32_t _i231; - for (_i231 = 0; _i231 < _size227; ++_i231) + uint32_t _size228; + ::apache::thrift::protocol::TType _etype231; + xfer += iprot->readListBegin(_etype231, _size228); + this->values.resize(_size228); + uint32_t _i232; + for (_i232 = 0; _i232 < _size228; ++_i232) { - xfer += iprot->readString(this->values[_i231]); + xfer += iprot->readString(this->values[_i232]); } xfer += iprot->readListEnd(); } @@ -5433,17 +5589,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size232; - ::apache::thrift::protocol::TType _ktype233; - ::apache::thrift::protocol::TType _vtype234; - xfer += iprot->readMapBegin(_ktype233, _vtype234, _size232); - uint32_t _i236; - for (_i236 = 0; _i236 < _size232; ++_i236) + uint32_t _size233; + ::apache::thrift::protocol::TType _ktype234; + ::apache::thrift::protocol::TType _vtype235; + xfer += iprot->readMapBegin(_ktype234, _vtype235, _size233); + uint32_t _i237; + for (_i237 = 0; _i237 < _size233; ++_i237) { - std::string _key237; - xfer += iprot->readString(_key237); - std::string& _val238 = this->parameters[_key237]; - xfer += iprot->readString(_val238); + std::string _key238; + xfer += iprot->readString(_key238); + std::string& _val239 = this->parameters[_key238]; + xfer += iprot->readString(_val239); } xfer += iprot->readMapEnd(); } @@ -5480,10 +5636,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 _iter239; - for (_iter239 = this->values.begin(); _iter239 != this->values.end(); ++_iter239) + std::vector<std::string> ::const_iterator _iter240; + for (_iter240 = this->values.begin(); _iter240 != this->values.end(); ++_iter240) { - xfer += oprot->writeString((*_iter239)); + xfer += oprot->writeString((*_iter240)); } xfer += oprot->writeListEnd(); } @@ -5512,11 +5668,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 _iter240; - for (_iter240 = this->parameters.begin(); _iter240 != this->parameters.end(); ++_iter240) + std::map<std::string, std::string> ::const_iterator _iter241; + for (_iter241 = this->parameters.begin(); _iter241 != this->parameters.end(); ++_iter241) { - xfer += oprot->writeString(_iter240->first); - xfer += oprot->writeString(_iter240->second); + xfer += oprot->writeString(_iter241->first); + xfer += oprot->writeString(_iter241->second); } xfer += oprot->writeMapEnd(); } @@ -5545,18 +5701,7 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other241) { - values = other241.values; - dbName = other241.dbName; - tableName = other241.tableName; - createTime = other241.createTime; - lastAccessTime = other241.lastAccessTime; - sd = other241.sd; - parameters = other241.parameters; - privileges = other241.privileges; - __isset = other241.__isset; -} -Partition& Partition::operator=(const Partition& other242) { +Partition::Partition(const Partition& other242) { values = other242.values; dbName = other242.dbName; tableName = other242.tableName; @@ -5566,6 +5711,17 @@ Partition& Partition::operator=(const Partition& other242) { parameters = other242.parameters; privileges = other242.privileges; __isset = other242.__isset; +} +Partition& Partition::operator=(const Partition& other243) { + values = other243.values; + dbName = other243.dbName; + tableName = other243.tableName; + createTime = other243.createTime; + lastAccessTime = other243.lastAccessTime; + sd = other243.sd; + parameters = other243.parameters; + privileges = other243.privileges; + __isset = other243.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -5637,14 +5793,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size243; - ::apache::thrift::protocol::TType _etype246; - xfer += iprot->readListBegin(_etype246, _size243); - this->values.resize(_size243); - uint32_t _i247; - for (_i247 = 0; _i247 < _size243; ++_i247) + uint32_t _size244; + ::apache::thrift::protocol::TType _etype247; + xfer += iprot->readListBegin(_etype247, _size244); + this->values.resize(_size244); + uint32_t _i248; + for (_i248 = 0; _i248 < _size244; ++_i248) { - xfer += iprot->readString(this->values[_i247]); + xfer += iprot->readString(this->values[_i248]); } xfer += iprot->readListEnd(); } @@ -5681,17 +5837,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size248; - ::apache::thrift::protocol::TType _ktype249; - ::apache::thrift::protocol::TType _vtype250; - xfer += iprot->readMapBegin(_ktype249, _vtype250, _size248); - uint32_t _i252; - for (_i252 = 0; _i252 < _size248; ++_i252) + uint32_t _size249; + ::apache::thrift::protocol::TType _ktype250; + ::apache::thrift::protocol::TType _vtype251; + xfer += iprot->readMapBegin(_ktype250, _vtype251, _size249); + uint32_t _i253; + for (_i253 = 0; _i253 < _size249; ++_i253) { - std::string _key253; - xfer += iprot->readString(_key253); - std::string& _val254 = this->parameters[_key253]; - xfer += iprot->readString(_val254); + std::string _key254; + xfer += iprot->readString(_key254); + std::string& _val255 = this->parameters[_key254]; + xfer += iprot->readString(_val255); } xfer += iprot->readMapEnd(); } @@ -5728,10 +5884,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 _iter255; - for (_iter255 = this->values.begin(); _iter255 != this->values.end(); ++_iter255) + std::vector<std::string> ::const_iterator _iter256; + for (_iter256 = this->values.begin(); _iter256 != this->values.end(); ++_iter256) { - xfer += oprot->writeString((*_iter255)); + xfer += oprot->writeString((*_iter256)); } xfer += oprot->writeListEnd(); } @@ -5752,11 +5908,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 _iter256; - for (_iter256 = this->parameters.begin(); _iter256 != this->parameters.end(); ++_iter256) + std::map<std::string, std::string> ::const_iterator _iter257; + for (_iter257 = this->parameters.begin(); _iter257 != this->parameters.end(); ++_iter257) { - xfer += oprot->writeString(_iter256->first); - xfer += oprot->writeString(_iter256->second); + xfer += oprot->writeString(_iter257->first); + xfer += oprot->writeString(_iter257->second); } xfer += oprot->writeMapEnd(); } @@ -5783,16 +5939,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other257) { - values = other257.values; - createTime = other257.createTime; - lastAccessTime = other257.lastAccessTime; - relativePath = other257.relativePath; - parameters = other257.parameters; - privileges = other257.privileges; - __isset = other257.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other258) { +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other258) { values = other258.values; createTime = other258.createTime; lastAccessTime = other258.lastAccessTime; @@ -5800,6 +5947,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe parameters = other258.parameters; privileges = other258.privileges; __isset = other258.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other259) { + values = other259.values; + createTime = other259.createTime; + lastAccessTime = other259.lastAccessTime; + relativePath = other259.relativePath; + parameters = other259.parameters; + privileges = other259.privileges; + __isset = other259.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -5852,14 +6008,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size259; - ::apache::thrift::protocol::TType _etype262; - xfer += iprot->readListBegin(_etype262, _size259); - this->partitions.resize(_size259); - uint32_t _i263; - for (_i263 = 0; _i263 < _size259; ++_i263) + uint32_t _size260; + ::apache::thrift::protocol::TType _etype263; + xfer += iprot->readListBegin(_etype263, _size260); + this->partitions.resize(_size260); + uint32_t _i264; + for (_i264 = 0; _i264 < _size260; ++_i264) { - xfer += this->partitions[_i263].read(iprot); + xfer += this->partitions[_i264].read(iprot); } xfer += iprot->readListEnd(); } @@ -5896,10 +6052,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 _iter264; - for (_iter264 = this->partitions.begin(); _iter264 != this->partitions.end(); ++_iter264) + std::vector<PartitionWithoutSD> ::const_iterator _iter265; + for (_iter265 = this->partitions.begin(); _iter265 != this->partitions.end(); ++_iter265) { - xfer += (*_iter264).write(oprot); + xfer += (*_iter265).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5921,15 +6077,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other265) { - partitions = other265.partitions; - sd = other265.sd; - __isset = other265.__isset; -} -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other266) { +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other266) { partitions = other266.partitions; sd = other266.sd; __isset = other266.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other267) { + partitions = other267.partitions; + sd = other267.sd; + __isset = other267.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -5974,14 +6130,14 @@ uint32_t PartitionListComposingSpec::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(); } @@ -6010,10 +6166,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 _iter272; - for (_iter272 = this->partitions.begin(); _iter272 != this->partitions.end(); ++_iter272) + std::vector<Partition> ::const_iterator _iter273; + for (_iter273 = this->partitions.begin(); _iter273 != this->partitions.end(); ++_iter273) { - xfer += (*_iter272).write(oprot); + xfer += (*_iter273).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6030,13 +6186,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other273) { - partitions = other273.partitions; - __isset = other273.__isset; -} -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other274) { +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other274) { partitions = other274.partitions; __isset = other274.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other275) { + partitions = other275.partitions; + __isset = other275.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -6188,21 +6344,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other275) { - dbName = other275.dbName; - tableName = other275.tableName; - rootPath = other275.rootPath; - sharedSDPartitionSpec = other275.sharedSDPartitionSpec; - partitionList = other275.partitionList; - __isset = other275.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other276) { +PartitionSpec::PartitionSpec(const PartitionSpec& other276) { dbName = other276.dbName; tableName = other276.tableName; rootPath = other276.rootPath; sharedSDPartitionSpec = other276.sharedSDPartitionSpec; partitionList = other276.partitionList; __isset = other276.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other277) { + dbName = other277.dbName; + tableName = other277.tableName; + rootPath = other277.rootPath; + sharedSDPartitionSpec = other277.sharedSDPartitionSpec; + partitionList = other277.partitionList; + __isset = other277.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -6350,17 +6506,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size277; - ::apache::thrift::protocol::TType _ktype278; - ::apache::thrift::protocol::TType _vtype279; - xfer += iprot->readMapBegin(_ktype278, _vtype279, _size277); - uint32_t _i281; - for (_i281 = 0; _i281 < _size277; ++_i281) + uint32_t _size278; + ::apache::thrift::protocol::TType _ktype279; + ::apache::thrift::protocol::TType _vtype280; + xfer += iprot->readMapBegin(_ktype279, _vtype280, _size278); + uint32_t _i282; + for (_i282 = 0; _i282 < _size278; ++_i282) { - std::string _key282; - xfer += iprot->readString(_key282); - std::string& _val283 = this->parameters[_key282]; - xfer += iprot->readString(_val283); + std::string _key283; + xfer += iprot->readString(_key283); + std::string& _val284 = this->parameters[_key283]; + xfer += iprot->readString(_val284); } xfer += iprot->readMapEnd(); } @@ -6429,11 +6585,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 _iter284; - for (_iter284 = this->parameters.begin(); _iter284 != this->parameters.end(); ++_iter284) + std::map<std::string, std::string> ::const_iterator _iter285; + for (_iter285 = this->parameters.begin(); _iter285 != this->parameters.end(); ++_iter285) { - xfer += oprot->writeString(_iter284->first); - xfer += oprot->writeString(_iter284->second); + xfer += oprot->writeString(_iter285->first); + xfer += oprot->writeString(_iter285->second); } xfer += oprot->writeMapEnd(); } @@ -6463,20 +6619,7 @@ void swap(Index &a, Index &b) { swap(a.__isset, b.__isset); } -Index::Index(const Index& other285) { - indexName = other285.indexName; - indexHandlerClass = other285.indexHandlerClass; - dbName = other285.dbName; - origTableName = other285.origTableName; - createTime = other285.createTime; - lastAccessTime = other285.lastAccessTime; - indexTableName = other285.indexTableName; - sd = other285.sd; - parameters = other285.parameters; - deferredRebuild = other285.deferredRebuild; - __isset = other285.__isset; -} -Index& Index::operator=(const Index& other286) { +Index::Index(const Index& other286) { indexName = other286.indexName; indexHandlerClass = other286.indexHandlerClass; dbName = other286.dbName; @@ -6488,6 +6631,19 @@ Index& Index::operator=(const Index& other286) { parameters = other286.parameters; deferredRebuild = other286.deferredRebuild; __isset = other286.__isset; +} +Index& Index::operator=(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; return *this; } void Index::printTo(std::ostream& out) const { @@ -6638,19 +6794,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other287) { - numTrues = other287.numTrues; - numFalses = other287.numFalses; - numNulls = other287.numNulls; - bitVectors = other287.bitVectors; - __isset = other287.__isset; -} -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other288) { +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other288) { numTrues = other288.numTrues; numFalses = other288.numFalses; numNulls = other288.numNulls; bitVectors = other288.bitVectors; __isset = other288.__isset; +} +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other289) { + numTrues = other289.numTrues; + numFalses = other289.numFalses; + numNulls = other289.numNulls; + bitVectors = other289.bitVectors; + __isset = other289.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -6813,21 +6969,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other289) { - lowValue = other289.lowValue; - highValue = other289.highValue; - numNulls = other289.numNulls; - numDVs = other289.numDVs; - bitVectors = other289.bitVectors; - __isset = other289.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other290) { +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other290) { lowValue = other290.lowValue; highValue = other290.highValue; numNulls = other290.numNulls; numDVs = other290.numDVs; bitVectors = other290.bitVectors; __isset = other290.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other291) { + lowValue = other291.lowValue; + highValue = other291.highValue; + numNulls = other291.numNulls; + numDVs = other291.numDVs; + bitVectors = other291.bitVectors; + __isset = other291.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -6991,21 +7147,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other291) { - lowValue = other291.lowValue; - highValue = other291.highValue; - numNulls = other291.numNulls; - numDVs = other291.numDVs; - bitVectors = other291.bitVectors; - __isset = other291.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other292) { +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other292) { lowValue = other292.lowValue; highValue = other292.highValue; numNulls = other292.numNulls; numDVs = other292.numDVs; bitVectors = other292.bitVectors; __isset = other292.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other293) { + lowValue = other293.lowValue; + highValue = other293.highValue; + numNulls = other293.numNulls; + numDVs = other293.numDVs; + bitVectors = other293.bitVectors; + __isset = other293.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -7171,21 +7327,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other293) { - maxColLen = other293.maxColLen; - avgColLen = other293.avgColLen; - numNulls = other293.numNulls; - numDVs = other293.numDVs; - bitVectors = other293.bitVectors; - __isset = other293.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other294) { +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other294) { maxColLen = other294.maxColLen; avgColLen = other294.avgColLen; numNulls = other294.numNulls; numDVs = other294.numDVs; bitVectors = other294.bitVectors; __isset = other294.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other295) { + maxColLen = other295.maxColLen; + avgColLen = other295.avgColLen; + numNulls = other295.numNulls; + numDVs = other295.numDVs; + bitVectors = other295.bitVectors; + __isset = other295.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -7331,19 +7487,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other295) { - maxColLen = other295.maxColLen; - avgColLen = other295.avgColLen; - numNulls = other295.numNulls; - bitVectors = other295.bitVectors; - __isset = other295.__isset; -} -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other296) { +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other296) { maxColLen = other296.maxColLen; avgColLen = other296.avgColLen; numNulls = other296.numNulls; bitVectors = other296.bitVectors; __isset = other296.__isset; +} +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other297) { + maxColLen = other297.maxColLen; + avgColLen = other297.avgColLen; + numNulls = other297.numNulls; + bitVectors = other297.bitVectors; + __isset = other297.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -7448,13 +7604,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other297) { - unscaled = other297.unscaled; - scale = other297.scale; -} -Decimal& Decimal::operator=(const Decimal& other298) { +Decimal::Decimal(const Decimal& other298) { unscaled = other298.unscaled; scale = other298.scale; +} +Decimal& Decimal::operator=(const Decimal& other299) { + unscaled = other299.unscaled; + scale = other299.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7615,21 +7771,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other299) { - lowValue = other299.lowValue; - highValue = other299.highValue; - numNulls = other299.numNulls; - numDVs = other299.numDVs; - bitVectors = other299.bitVectors; - __isset = other299.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other300) { +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other300) { lowValue = other300.lowValue; highValue = other300.highValue; numNulls = other300.numNulls; numDVs = other300.numDVs; bitVectors = other300.bitVectors; __isset = other300.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other301) { + lowValue = other301.lowValue; + highValue = other301.highValue; + numNulls = other301.numNulls; + numDVs = other301.numDVs; + bitVectors = other301.bitVectors; + __isset = other301.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7715,11 +7871,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other301) { - daysSinceEpoch = other301.daysSinceEpoch; -} -Date& Date::operator=(const Date& other302) { +Date::Date(const Date& other302) { daysSinceEpoch = other302.daysSinceEpoch; +} +Date& Date::operator=(const Date& other303) { + daysSinceEpoch = other303.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7879,21 +8035,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other303) { - lowValue = other303.lowValue; - highValue = other303.highValue; - numNulls = other303.numNulls; - numDVs = other303.numDVs; - bitVectors = other303.bitVectors; - __isset = other303.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other304) { +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other304) { lowValue = other304.lowValue; highValue = other304.highValue; numNulls = other304.numNulls; numDVs = other304.numDVs; bitVectors = other304.bitVectors; __isset = other304.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other305) { + lowValue = other305.lowValue; + highValue = other305.highValue; + numNulls = other305.numNulls; + numDVs = other305.numDVs; + bitVectors = other305.bitVectors; + __isset = other305.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -8079,17 +8235,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other305) { - booleanStats = other305.booleanStats; - longStats = other305.longStats; - doubleStats = other305.doubleStats; - stringStats = other305.stringStats; - binaryStats = other305.binaryStats; - decimalStats = other305.decimalStats; - dateStats = other305.dateStats; - __isset = other305.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other306) { +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other306) { booleanStats = other306.booleanStats; longStats = other306.longStats; doubleStats = other306.doubleStats; @@ -8098,6 +8244,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData decimalStats = other306.decimalStats; dateStats = other306.dateStats; __isset = other306.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(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; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -8225,15 +8381,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other307) { - colName = other307.colName; - colType = other307.colType; - statsData = other307.statsData; -} -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other308) { +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other308) { colName = other308.colName; colType = other308.colType; statsData = other308.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other309) { + colName = other309.colName; + colType = other309.colType; + statsData = other309.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -8396,21 +8552,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other309) { - isTblLevel = other309.isTblLevel; - dbName = other309.dbName; - tableName = other309.tableName; - partName = other309.partName; - lastAnalyzed = other309.lastAnalyzed; - __isset = other309.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other310) { +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other310) { isTblLevel = other310.isTblLevel; dbName = other310.dbName; tableName = other310.tableName; partName = other310.partName; lastAnalyzed = other310.lastAnalyzed; __isset = other310.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other311) { + isTblLevel = other311.isTblLevel; + dbName = other311.dbName; + tableName = other311.tableName; + partName = other311.partName; + lastAnalyzed = other311.lastAnalyzed; + __isset = other311.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -8472,14 +8628,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size311; - ::apache::thrift::protocol::TType _etype314; - xfer += iprot->readListBegin(_etype314, _size311); - this->statsObj.resize(_size311); - uint32_t _i315; - for (_i315 = 0; _i315 < _size311; ++_i315) + uint32_t _size312; + ::apache::thrift::protocol::TType _etype315; + xfer += iprot->readListBegin(_etype315, _size312); + this->statsObj.resize(_size312); + uint32_t _i316; + for (_i316 = 0; _i316 < _size312; ++_i316) { - xfer += this->statsObj[_i315].read(iprot); + xfer += this->statsObj[_i316].read(iprot); } xfer += iprot->readListEnd(); } @@ -8516,10 +8672,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 _iter316; - for (_iter316 = this->statsObj.begin(); _iter316 != this->statsObj.end(); ++_iter316) + std::vector<ColumnStatisticsObj> ::const_iterator _iter317; + for (_iter317 = this->statsObj.begin(); _iter317 != this->statsObj.end(); ++_iter317) { - xfer += (*_iter316).write(oprot); + xfer += (*_iter317).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8536,13 +8692,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other317) { - statsDesc = other317.statsDesc; - statsObj = other317.statsObj; -} -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other318) { +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other318) { statsDesc = other318.statsDesc; statsObj = other318.statsObj; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other319) { + statsDesc = other319.statsDesc; + statsObj = other319.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8593,14 +8749,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - 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) + uint32_t _size320; + ::apache::thrift::protocol::TType _etype323; + xfer += iprot->readListBegin(_etype323, _size320); + this->colStats.resize(_size320); + uint32_t _i324; + for (_i324 = 0; _i324 < _size320; ++_i324) { - xfer += this->colStats[_i323].read(iprot); + xfer += this->colStats[_i324].read(iprot); } xfer += iprot->readListEnd(); } @@ -8641,10 +8797,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 _iter324; - for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); ++_iter324) + std::vector<ColumnStatisticsObj> ::const_iterator _iter325; + for (_iter325 = this->colStats.begin(); _iter325 != this->colStats.end(); ++_iter325) { - xfer += (*_iter324).write(oprot); + xfer += (*_iter325).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8665,13 +8821,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other325) { - colStats = other325.colStats; - partsFound = other325.partsFound; -} -AggrStats& AggrStats::operator=(const AggrStats& other326) { +AggrStats::AggrStats(const AggrStats& other326) { colStats = other326.colStats; partsFound = other326.partsFound; +} +AggrStats& AggrStats::operator=(const AggrStats& other327) { + colStats = other327.colStats; + partsFound = other327.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8722,14 +8878,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* 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(); } @@ -8768,10 +8924,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 _iter332; - for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); ++_iter332) + std::vector<ColumnStatistics> ::const_iterator _iter333; + for (_iter333 = this->colStats.begin(); _iter333 != this->colStats.end(); ++_iter333) { - xfer += (*_iter332).write(oprot); + xfer += (*_iter333).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8794,15 +8950,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other333) { - colStats = other333.colStats; - needMerge = other333.needMerge; - __isset = other333.__isset; -} -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other334) { +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other334) { colStats = other334.colStats; needMerge = other334.needMerge; __isset = other334.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other335) { + colStats = other335.colStats; + needMerge = other335.needMerge; + __isset = other335.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -8851,14 +9007,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size335; - ::apache::thrift::protocol::TType _etype338; - xfer += iprot->readListBegin(_etype338, _size335); - this->fieldSchemas.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->fieldSchemas.resize(_size336); + uint32_t _i340; + for (_i340 = 0; _i340 < _size336; ++_i340) { - xfer += this->fieldSchemas[_i339].read(iprot); + xfer += this->fieldSchemas[_i340].read(iprot); } xfer += iprot->readListEnd(); } @@ -8871,17 +9027,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size340; - ::apache::thrift::protocol::TType _ktype341; - ::apache::thrift::protocol::TType _vtype342; - xfer += iprot->readMapBegin(_ktype341, _vtype342, _size340); - uint32_t _i344; - for (_i344 = 0; _i344 < _size340; ++_i344) + uint32_t _size341; + ::apache::thrift::protocol::TType _ktype342; + ::apache::thrift::protocol::TType _vtype343; + xfer += iprot->readMapBegin(_ktype342, _vtype343, _size341); + uint32_t _i345; + for (_i345 = 0; _i345 < _size341; ++_i345) { - std::string _key345; - xfer += iprot->readString(_key345); - std::string& _val346 = this->properties[_key345]; - xfer += iprot->readString(_val346); + std::string _key346; + xfer += iprot->readString(_key346); + std::string& _val347 = this->properties[_key346]; + xfer += iprot->readString(_val347); } xfer += iprot->readMapEnd(); } @@ -8910,10 +9066,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 _iter347; - for (_iter347 = this->fieldSchemas.begin(); _iter347 != this->fieldSchemas.end(); ++_iter347) + std::vector<FieldSchema> ::const_iterator _iter348; + for (_iter348 = this->fieldSchemas.begin(); _iter348 != this->fieldSchemas.end(); ++_iter348) { - xfer += (*_iter347).write(oprot); + xfer += (*_iter348).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8922,11 +9078,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 _iter348; - for (_iter348 = this->properties.begin(); _iter348 != this->properties.end(); ++_iter348) + std::map<std::string, std::string> ::const_iterator _iter349; + for (_iter349 = this->properties.begin(); _iter349 != this->properties.end(); ++_iter349) { - xfer += oprot->writeString(_iter348->first); - xfer += oprot->writeString(_iter348->second); + xfer += oprot->writeString(_iter349->first); + xfer += oprot->writeString(_iter349->second); } xfer += oprot->writeMapEnd(); } @@ -8944,15 +9100,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other349) { - fieldSchemas = other349.fieldSchemas; - properties = other349.properties; - __isset = other349.__isset; -} -Schema& Schema::operator=(const Schema& other350) { +Schema::Schema(const Schema& other350) { fieldSchemas = other350.fieldSchemas; properties = other350.properties; __isset = other350.__isset; +} +Schema& Schema::operator=(const Schema& other351) { + fieldSchemas = other351.fieldSchemas; + properties = other351.properties; + __isset = other351.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -8997,17 +9153,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size351; - ::apache::thrift::protocol::TType _ktype352; - ::apache::thrift::protocol::TType _vtype353; - xfer += iprot->readMapBegin(_ktype352, _vtype353, _size351); - uint32_t _i355; - for (_i355 = 0; _i355 < _size351; ++_i355) + uint32_t _size352; + ::apache::thrift::protocol::TType _ktype353; + ::apache::thrift::protocol::TType _vtype354; + xfer += iprot->readMapBegin(_ktype353, _vtype354, _size352); + uint32_t _i356; + for (_i356 = 0; _i356 < _size352; ++_i356) { - std::string _key356; - xfer += iprot->readString(_key356); - std::string& _val357 = this->properties[_key356]; - xfer += iprot->readString(_val357); + std::string _key357; + xfer += iprot->readString(_key357); + std::string& _val358 = this->properties[_key357]; + xfer += iprot->readString(_val358); } xfer += iprot->readMapEnd(); } @@ -9036,11 +9192,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 _iter358; - for (_iter358 = this->properties.begin(); _iter358 != this->properties.end(); ++_iter358) + std::map<std::string, std::string> ::const_iterator _iter359; + for (_iter359 = this->properties.begin(); _iter359 != this->properties.end(); ++_iter359) { - xfer += oprot->writeString(_iter358->first); - xfer += oprot->writeString(_iter358->second); + xfer += oprot->writeString(_iter359->first); + xfer += oprot->writeString(_iter359->second); } xfer += oprot->writeMapEnd(); } @@ -9057,13 +9213,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other359) { - properties = other359.properties; - __isset = other359.__isset; -} -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other360) { +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other360) { properties = other360.properties; __isset = other360.__isset; +} +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other361) { + properties = other361.properties; + __isset = other361.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -9165,13 +9321,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other361) { - db_name = other361.db_name; - tbl_name = other361.tbl_name; -} -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other362) { +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other362) { db_name = other362.db_name; tbl_name = other362.tbl_name; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other363) { + db_name = other363.db_name; + tbl_name = other363.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -9217,14 +9373,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size363; - ::apache::thrift::protocol::TType _etype366; - xfer += iprot->readListBegin(_etype366, _size363); - this->primaryKeys.resize(_size363); - uint32_t _i367; - for (_i367 = 0; _i367 < _size363; ++_i367) + uint32_t _size364; + ::apache::thrift::protocol::TType _etype367; + xfer += iprot->readListBegin(_etype367, _size364); + this->primaryKeys.resize(_size364); + uint32_t _i368; + for (_i368 = 0; _i368 < _size364; ++_i368) { - xfer += this->primaryKeys[_i367].read(iprot); + xfer += this->primaryKeys[_i368].read(iprot); } xfer += iprot->readListEnd(); } @@ -9255,10 +9411,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 _iter368; - for (_iter368 = this->primaryKeys.begin(); _iter368 != this->primaryKeys.end(); ++_iter368) + std::vector<SQLPrimaryKey> ::const_iterator _iter369; + for (_iter369 = this->primaryKeys.begin(); _iter369 != this->primaryKeys.end(); ++_iter369) { - xfer += (*_iter368).write(oprot); + xfer += (*_iter369).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9274,11 +9430,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other369) { - primaryKeys = other369.primaryKeys; -} -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other370) { +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other370) { primaryKeys = other370.primaryKeys; +} +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other371) { + primaryKeys = other371.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -9409,19 +9565,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other371) { - parent_db_name = other371.parent_db_name; - parent_tbl_name = other371.parent_tbl_name; - foreign_db_name = other371.foreign_db_name; - foreign_tbl_name = other371.foreign_tbl_name; - __isset = other371.__isset; -} -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other372) { +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other372) { parent_db_name = other372.parent_db_name; parent_tbl_name = other372.parent_tbl_name; foreign_db_name = other372.foreign_db_name; foreign_tbl_name = other372.foreign_tbl_name; __isset = other372.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(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; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -9469,14 +9625,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size373; - ::apache::thrift::protocol::TType _etype376; - xfer += iprot->readListBegin(_etype376, _size373); - this->foreignKeys.resize(_size373); - uint32_t _i377; - for (_i377 = 0; _i377 < _size373; ++_i377) + uint32_t _size374; + ::apache::thrift::protocol::TType _etype377; + xfer += iprot->readListBegin(_etype377, _size374); + this->foreignKeys.resize(_size374); + uint32_t _i378; + for (_i378 = 0; _i378 < _size374; ++_i378) { - xfer += this->foreignKeys[_i377].read(iprot); + xfer += this->foreignKeys[_i378].read(iprot); } xfer += iprot->readListEnd(); } @@ -9507,10 +9663,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1
<TRUNCATED>