http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/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 244b7ab..4a7c6bf 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 }; @@ -4235,6 +4301,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); @@ -4295,6 +4381,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 ecast146; + xfer += iprot->readI32(ecast146); + this->serdeType = (SerdeType::type)ecast146; + this->__isset.serdeType = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -4323,16 +4443,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 _iter146; - for (_iter146 = this->parameters.begin(); _iter146 != this->parameters.end(); ++_iter146) + std::map<std::string, std::string> ::const_iterator _iter147; + for (_iter147 = this->parameters.begin(); _iter147 != this->parameters.end(); ++_iter147) { - xfer += oprot->writeString(_iter146->first); - xfer += oprot->writeString(_iter146->second); + xfer += oprot->writeString(_iter147->first); + xfer += oprot->writeString(_iter147->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; @@ -4343,20 +4483,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& other147) { - name = other147.name; - serializationLib = other147.serializationLib; - parameters = other147.parameters; - __isset = other147.__isset; -} -SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other148) { +SerDeInfo::SerDeInfo(const SerDeInfo& other148) { name = other148.name; serializationLib = other148.serializationLib; parameters = other148.parameters; + description = other148.description; + serializerClass = other148.serializerClass; + deserializerClass = other148.deserializerClass; + serdeType = other148.serdeType; __isset = other148.__isset; +} +SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other149) { + name = other149.name; + serializationLib = other149.serializationLib; + parameters = other149.parameters; + description = other149.description; + serializerClass = other149.serializerClass; + deserializerClass = other149.deserializerClass; + serdeType = other149.serdeType; + __isset = other149.__isset; return *this; } void SerDeInfo::printTo(std::ostream& out) const { @@ -4365,6 +4517,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 << ")"; } @@ -4455,15 +4611,15 @@ void swap(Order &a, Order &b) { swap(a.__isset, b.__isset); } -Order::Order(const Order& other149) { - col = other149.col; - order = other149.order; - __isset = other149.__isset; -} -Order& Order::operator=(const Order& other150) { +Order::Order(const Order& other150) { col = other150.col; order = other150.order; __isset = other150.__isset; +} +Order& Order::operator=(const Order& other151) { + col = other151.col; + order = other151.order; + __isset = other151.__isset; return *this; } void Order::printTo(std::ostream& out) const { @@ -4516,14 +4672,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColNames.clear(); - uint32_t _size151; - ::apache::thrift::protocol::TType _etype154; - xfer += iprot->readListBegin(_etype154, _size151); - this->skewedColNames.resize(_size151); - uint32_t _i155; - for (_i155 = 0; _i155 < _size151; ++_i155) + uint32_t _size152; + ::apache::thrift::protocol::TType _etype155; + xfer += iprot->readListBegin(_etype155, _size152); + this->skewedColNames.resize(_size152); + uint32_t _i156; + for (_i156 = 0; _i156 < _size152; ++_i156) { - xfer += iprot->readString(this->skewedColNames[_i155]); + xfer += iprot->readString(this->skewedColNames[_i156]); } xfer += iprot->readListEnd(); } @@ -4536,23 +4692,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColValues.clear(); - uint32_t _size156; - ::apache::thrift::protocol::TType _etype159; - xfer += iprot->readListBegin(_etype159, _size156); - this->skewedColValues.resize(_size156); - uint32_t _i160; - for (_i160 = 0; _i160 < _size156; ++_i160) + uint32_t _size157; + ::apache::thrift::protocol::TType _etype160; + xfer += iprot->readListBegin(_etype160, _size157); + this->skewedColValues.resize(_size157); + uint32_t _i161; + for (_i161 = 0; _i161 < _size157; ++_i161) { { - this->skewedColValues[_i160].clear(); - uint32_t _size161; - ::apache::thrift::protocol::TType _etype164; - xfer += iprot->readListBegin(_etype164, _size161); - this->skewedColValues[_i160].resize(_size161); - uint32_t _i165; - for (_i165 = 0; _i165 < _size161; ++_i165) + this->skewedColValues[_i161].clear(); + uint32_t _size162; + ::apache::thrift::protocol::TType _etype165; + xfer += iprot->readListBegin(_etype165, _size162); + this->skewedColValues[_i161].resize(_size162); + uint32_t _i166; + for (_i166 = 0; _i166 < _size162; ++_i166) { - xfer += iprot->readString(this->skewedColValues[_i160][_i165]); + xfer += iprot->readString(this->skewedColValues[_i161][_i166]); } xfer += iprot->readListEnd(); } @@ -4568,29 +4724,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->skewedColValueLocationMaps.clear(); - uint32_t _size166; - ::apache::thrift::protocol::TType _ktype167; - ::apache::thrift::protocol::TType _vtype168; - xfer += iprot->readMapBegin(_ktype167, _vtype168, _size166); - uint32_t _i170; - for (_i170 = 0; _i170 < _size166; ++_i170) + uint32_t _size167; + ::apache::thrift::protocol::TType _ktype168; + ::apache::thrift::protocol::TType _vtype169; + xfer += iprot->readMapBegin(_ktype168, _vtype169, _size167); + uint32_t _i171; + for (_i171 = 0; _i171 < _size167; ++_i171) { - std::vector<std::string> _key171; + std::vector<std::string> _key172; { - _key171.clear(); - uint32_t _size173; - ::apache::thrift::protocol::TType _etype176; - xfer += iprot->readListBegin(_etype176, _size173); - _key171.resize(_size173); - uint32_t _i177; - for (_i177 = 0; _i177 < _size173; ++_i177) + _key172.clear(); + uint32_t _size174; + ::apache::thrift::protocol::TType _etype177; + xfer += iprot->readListBegin(_etype177, _size174); + _key172.resize(_size174); + uint32_t _i178; + for (_i178 = 0; _i178 < _size174; ++_i178) { - xfer += iprot->readString(_key171[_i177]); + xfer += iprot->readString(_key172[_i178]); } xfer += iprot->readListEnd(); } - std::string& _val172 = this->skewedColValueLocationMaps[_key171]; - xfer += iprot->readString(_val172); + std::string& _val173 = this->skewedColValueLocationMaps[_key172]; + xfer += iprot->readString(_val173); } xfer += iprot->readMapEnd(); } @@ -4619,10 +4775,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 _iter178; - for (_iter178 = this->skewedColNames.begin(); _iter178 != this->skewedColNames.end(); ++_iter178) + std::vector<std::string> ::const_iterator _iter179; + for (_iter179 = this->skewedColNames.begin(); _iter179 != this->skewedColNames.end(); ++_iter179) { - xfer += oprot->writeString((*_iter178)); + xfer += oprot->writeString((*_iter179)); } xfer += oprot->writeListEnd(); } @@ -4631,15 +4787,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 _iter179; - for (_iter179 = this->skewedColValues.begin(); _iter179 != this->skewedColValues.end(); ++_iter179) + std::vector<std::vector<std::string> > ::const_iterator _iter180; + for (_iter180 = this->skewedColValues.begin(); _iter180 != this->skewedColValues.end(); ++_iter180) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter179).size())); - std::vector<std::string> ::const_iterator _iter180; - for (_iter180 = (*_iter179).begin(); _iter180 != (*_iter179).end(); ++_iter180) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter180).size())); + std::vector<std::string> ::const_iterator _iter181; + for (_iter181 = (*_iter180).begin(); _iter181 != (*_iter180).end(); ++_iter181) { - xfer += oprot->writeString((*_iter180)); + xfer += oprot->writeString((*_iter181)); } xfer += oprot->writeListEnd(); } @@ -4651,19 +4807,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 _iter181; - for (_iter181 = this->skewedColValueLocationMaps.begin(); _iter181 != this->skewedColValueLocationMaps.end(); ++_iter181) + std::map<std::vector<std::string> , std::string> ::const_iterator _iter182; + for (_iter182 = this->skewedColValueLocationMaps.begin(); _iter182 != this->skewedColValueLocationMaps.end(); ++_iter182) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter181->first.size())); - std::vector<std::string> ::const_iterator _iter182; - for (_iter182 = _iter181->first.begin(); _iter182 != _iter181->first.end(); ++_iter182) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter182->first.size())); + std::vector<std::string> ::const_iterator _iter183; + for (_iter183 = _iter182->first.begin(); _iter183 != _iter182->first.end(); ++_iter183) { - xfer += oprot->writeString((*_iter182)); + xfer += oprot->writeString((*_iter183)); } xfer += oprot->writeListEnd(); } - xfer += oprot->writeString(_iter181->second); + xfer += oprot->writeString(_iter182->second); } xfer += oprot->writeMapEnd(); } @@ -4682,17 +4838,17 @@ void swap(SkewedInfo &a, SkewedInfo &b) { swap(a.__isset, b.__isset); } -SkewedInfo::SkewedInfo(const SkewedInfo& other183) { - skewedColNames = other183.skewedColNames; - skewedColValues = other183.skewedColValues; - skewedColValueLocationMaps = other183.skewedColValueLocationMaps; - __isset = other183.__isset; -} -SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other184) { +SkewedInfo::SkewedInfo(const SkewedInfo& other184) { skewedColNames = other184.skewedColNames; skewedColValues = other184.skewedColValues; skewedColValueLocationMaps = other184.skewedColValueLocationMaps; __isset = other184.__isset; +} +SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other185) { + skewedColNames = other185.skewedColNames; + skewedColValues = other185.skewedColValues; + skewedColValueLocationMaps = other185.skewedColValueLocationMaps; + __isset = other185.__isset; return *this; } void SkewedInfo::printTo(std::ostream& out) const { @@ -4784,14 +4940,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size185; - ::apache::thrift::protocol::TType _etype188; - xfer += iprot->readListBegin(_etype188, _size185); - this->cols.resize(_size185); - uint32_t _i189; - for (_i189 = 0; _i189 < _size185; ++_i189) + uint32_t _size186; + ::apache::thrift::protocol::TType _etype189; + xfer += iprot->readListBegin(_etype189, _size186); + this->cols.resize(_size186); + uint32_t _i190; + for (_i190 = 0; _i190 < _size186; ++_i190) { - xfer += this->cols[_i189].read(iprot); + xfer += this->cols[_i190].read(iprot); } xfer += iprot->readListEnd(); } @@ -4852,14 +5008,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->bucketCols.clear(); - uint32_t _size190; - ::apache::thrift::protocol::TType _etype193; - xfer += iprot->readListBegin(_etype193, _size190); - this->bucketCols.resize(_size190); - uint32_t _i194; - for (_i194 = 0; _i194 < _size190; ++_i194) + uint32_t _size191; + ::apache::thrift::protocol::TType _etype194; + xfer += iprot->readListBegin(_etype194, _size191); + this->bucketCols.resize(_size191); + uint32_t _i195; + for (_i195 = 0; _i195 < _size191; ++_i195) { - xfer += iprot->readString(this->bucketCols[_i194]); + xfer += iprot->readString(this->bucketCols[_i195]); } xfer += iprot->readListEnd(); } @@ -4872,14 +5028,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sortCols.clear(); - uint32_t _size195; - ::apache::thrift::protocol::TType _etype198; - xfer += iprot->readListBegin(_etype198, _size195); - this->sortCols.resize(_size195); - uint32_t _i199; - for (_i199 = 0; _i199 < _size195; ++_i199) + uint32_t _size196; + ::apache::thrift::protocol::TType _etype199; + xfer += iprot->readListBegin(_etype199, _size196); + this->sortCols.resize(_size196); + uint32_t _i200; + for (_i200 = 0; _i200 < _size196; ++_i200) { - xfer += this->sortCols[_i199].read(iprot); + xfer += this->sortCols[_i200].read(iprot); } xfer += iprot->readListEnd(); } @@ -4892,17 +5048,17 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size200; - ::apache::thrift::protocol::TType _ktype201; - ::apache::thrift::protocol::TType _vtype202; - xfer += iprot->readMapBegin(_ktype201, _vtype202, _size200); - uint32_t _i204; - for (_i204 = 0; _i204 < _size200; ++_i204) + uint32_t _size201; + ::apache::thrift::protocol::TType _ktype202; + ::apache::thrift::protocol::TType _vtype203; + xfer += iprot->readMapBegin(_ktype202, _vtype203, _size201); + uint32_t _i205; + for (_i205 = 0; _i205 < _size201; ++_i205) { - std::string _key205; - xfer += iprot->readString(_key205); - std::string& _val206 = this->parameters[_key205]; - xfer += iprot->readString(_val206); + std::string _key206; + xfer += iprot->readString(_key206); + std::string& _val207 = this->parameters[_key206]; + xfer += iprot->readString(_val207); } xfer += iprot->readMapEnd(); } @@ -4947,10 +5103,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 _iter207; - for (_iter207 = this->cols.begin(); _iter207 != this->cols.end(); ++_iter207) + std::vector<FieldSchema> ::const_iterator _iter208; + for (_iter208 = this->cols.begin(); _iter208 != this->cols.end(); ++_iter208) { - xfer += (*_iter207).write(oprot); + xfer += (*_iter208).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4983,10 +5139,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 _iter208; - for (_iter208 = this->bucketCols.begin(); _iter208 != this->bucketCols.end(); ++_iter208) + std::vector<std::string> ::const_iterator _iter209; + for (_iter209 = this->bucketCols.begin(); _iter209 != this->bucketCols.end(); ++_iter209) { - xfer += oprot->writeString((*_iter208)); + xfer += oprot->writeString((*_iter209)); } xfer += oprot->writeListEnd(); } @@ -4995,10 +5151,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 _iter209; - for (_iter209 = this->sortCols.begin(); _iter209 != this->sortCols.end(); ++_iter209) + std::vector<Order> ::const_iterator _iter210; + for (_iter210 = this->sortCols.begin(); _iter210 != this->sortCols.end(); ++_iter210) { - xfer += (*_iter209).write(oprot); + xfer += (*_iter210).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5007,11 +5163,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 _iter210; - for (_iter210 = this->parameters.begin(); _iter210 != this->parameters.end(); ++_iter210) + std::map<std::string, std::string> ::const_iterator _iter211; + for (_iter211 = this->parameters.begin(); _iter211 != this->parameters.end(); ++_iter211) { - xfer += oprot->writeString(_iter210->first); - xfer += oprot->writeString(_iter210->second); + xfer += oprot->writeString(_iter211->first); + xfer += oprot->writeString(_iter211->second); } xfer += oprot->writeMapEnd(); } @@ -5049,22 +5205,7 @@ void swap(StorageDescriptor &a, StorageDescriptor &b) { swap(a.__isset, b.__isset); } -StorageDescriptor::StorageDescriptor(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; -} -StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other212) { +StorageDescriptor::StorageDescriptor(const StorageDescriptor& other212) { cols = other212.cols; location = other212.location; inputFormat = other212.inputFormat; @@ -5078,6 +5219,21 @@ StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other21 skewedInfo = other212.skewedInfo; storedAsSubDirectories = other212.storedAsSubDirectories; __isset = other212.__isset; +} +StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other213) { + cols = other213.cols; + location = other213.location; + inputFormat = other213.inputFormat; + outputFormat = other213.outputFormat; + compressed = other213.compressed; + numBuckets = other213.numBuckets; + serdeInfo = other213.serdeInfo; + bucketCols = other213.bucketCols; + sortCols = other213.sortCols; + parameters = other213.parameters; + skewedInfo = other213.skewedInfo; + storedAsSubDirectories = other213.storedAsSubDirectories; + __isset = other213.__isset; return *this; } void StorageDescriptor::printTo(std::ostream& out) const { @@ -5252,14 +5408,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size213; - ::apache::thrift::protocol::TType _etype216; - xfer += iprot->readListBegin(_etype216, _size213); - this->partitionKeys.resize(_size213); - uint32_t _i217; - for (_i217 = 0; _i217 < _size213; ++_i217) + uint32_t _size214; + ::apache::thrift::protocol::TType _etype217; + xfer += iprot->readListBegin(_etype217, _size214); + this->partitionKeys.resize(_size214); + uint32_t _i218; + for (_i218 = 0; _i218 < _size214; ++_i218) { - xfer += this->partitionKeys[_i217].read(iprot); + xfer += this->partitionKeys[_i218].read(iprot); } xfer += iprot->readListEnd(); } @@ -5272,17 +5428,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size218; - ::apache::thrift::protocol::TType _ktype219; - ::apache::thrift::protocol::TType _vtype220; - xfer += iprot->readMapBegin(_ktype219, _vtype220, _size218); - uint32_t _i222; - for (_i222 = 0; _i222 < _size218; ++_i222) + uint32_t _size219; + ::apache::thrift::protocol::TType _ktype220; + ::apache::thrift::protocol::TType _vtype221; + xfer += iprot->readMapBegin(_ktype220, _vtype221, _size219); + uint32_t _i223; + for (_i223 = 0; _i223 < _size219; ++_i223) { - std::string _key223; - xfer += iprot->readString(_key223); - std::string& _val224 = this->parameters[_key223]; - xfer += iprot->readString(_val224); + std::string _key224; + xfer += iprot->readString(_key224); + std::string& _val225 = this->parameters[_key224]; + xfer += iprot->readString(_val225); } xfer += iprot->readMapEnd(); } @@ -5395,10 +5551,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 _iter225; - for (_iter225 = this->partitionKeys.begin(); _iter225 != this->partitionKeys.end(); ++_iter225) + std::vector<FieldSchema> ::const_iterator _iter226; + for (_iter226 = this->partitionKeys.begin(); _iter226 != this->partitionKeys.end(); ++_iter226) { - xfer += (*_iter225).write(oprot); + xfer += (*_iter226).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5407,11 +5563,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 _iter226; - for (_iter226 = this->parameters.begin(); _iter226 != this->parameters.end(); ++_iter226) + std::map<std::string, std::string> ::const_iterator _iter227; + for (_iter227 = this->parameters.begin(); _iter227 != this->parameters.end(); ++_iter227) { - xfer += oprot->writeString(_iter226->first); - xfer += oprot->writeString(_iter226->second); + xfer += oprot->writeString(_iter227->first); + xfer += oprot->writeString(_iter227->second); } xfer += oprot->writeMapEnd(); } @@ -5475,26 +5631,7 @@ void swap(Table &a, Table &b) { swap(a.__isset, b.__isset); } -Table::Table(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; -} -Table& Table::operator=(const Table& other228) { +Table::Table(const Table& other228) { tableName = other228.tableName; dbName = other228.dbName; owner = other228.owner; @@ -5512,6 +5649,25 @@ Table& Table::operator=(const Table& other228) { rewriteEnabled = other228.rewriteEnabled; creationMetadata = other228.creationMetadata; __isset = other228.__isset; +} +Table& Table::operator=(const Table& other229) { + tableName = other229.tableName; + dbName = other229.dbName; + owner = other229.owner; + createTime = other229.createTime; + lastAccessTime = other229.lastAccessTime; + retention = other229.retention; + sd = other229.sd; + partitionKeys = other229.partitionKeys; + parameters = other229.parameters; + viewOriginalText = other229.viewOriginalText; + viewExpandedText = other229.viewExpandedText; + tableType = other229.tableType; + privileges = other229.privileges; + temporary = other229.temporary; + rewriteEnabled = other229.rewriteEnabled; + creationMetadata = other229.creationMetadata; + __isset = other229.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -5599,14 +5755,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size229; - ::apache::thrift::protocol::TType _etype232; - xfer += iprot->readListBegin(_etype232, _size229); - this->values.resize(_size229); - uint32_t _i233; - for (_i233 = 0; _i233 < _size229; ++_i233) + uint32_t _size230; + ::apache::thrift::protocol::TType _etype233; + xfer += iprot->readListBegin(_etype233, _size230); + this->values.resize(_size230); + uint32_t _i234; + for (_i234 = 0; _i234 < _size230; ++_i234) { - xfer += iprot->readString(this->values[_i233]); + xfer += iprot->readString(this->values[_i234]); } xfer += iprot->readListEnd(); } @@ -5659,17 +5815,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size234; - ::apache::thrift::protocol::TType _ktype235; - ::apache::thrift::protocol::TType _vtype236; - xfer += iprot->readMapBegin(_ktype235, _vtype236, _size234); - uint32_t _i238; - for (_i238 = 0; _i238 < _size234; ++_i238) + uint32_t _size235; + ::apache::thrift::protocol::TType _ktype236; + ::apache::thrift::protocol::TType _vtype237; + xfer += iprot->readMapBegin(_ktype236, _vtype237, _size235); + uint32_t _i239; + for (_i239 = 0; _i239 < _size235; ++_i239) { - std::string _key239; - xfer += iprot->readString(_key239); - std::string& _val240 = this->parameters[_key239]; - xfer += iprot->readString(_val240); + std::string _key240; + xfer += iprot->readString(_key240); + std::string& _val241 = this->parameters[_key240]; + xfer += iprot->readString(_val241); } xfer += iprot->readMapEnd(); } @@ -5706,10 +5862,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 _iter241; - for (_iter241 = this->values.begin(); _iter241 != this->values.end(); ++_iter241) + std::vector<std::string> ::const_iterator _iter242; + for (_iter242 = this->values.begin(); _iter242 != this->values.end(); ++_iter242) { - xfer += oprot->writeString((*_iter241)); + xfer += oprot->writeString((*_iter242)); } xfer += oprot->writeListEnd(); } @@ -5738,11 +5894,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 _iter242; - for (_iter242 = this->parameters.begin(); _iter242 != this->parameters.end(); ++_iter242) + std::map<std::string, std::string> ::const_iterator _iter243; + for (_iter243 = this->parameters.begin(); _iter243 != this->parameters.end(); ++_iter243) { - xfer += oprot->writeString(_iter242->first); - xfer += oprot->writeString(_iter242->second); + xfer += oprot->writeString(_iter243->first); + xfer += oprot->writeString(_iter243->second); } xfer += oprot->writeMapEnd(); } @@ -5771,18 +5927,7 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(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; -} -Partition& Partition::operator=(const Partition& other244) { +Partition::Partition(const Partition& other244) { values = other244.values; dbName = other244.dbName; tableName = other244.tableName; @@ -5792,6 +5937,17 @@ Partition& Partition::operator=(const Partition& other244) { parameters = other244.parameters; privileges = other244.privileges; __isset = other244.__isset; +} +Partition& Partition::operator=(const Partition& other245) { + values = other245.values; + dbName = other245.dbName; + tableName = other245.tableName; + createTime = other245.createTime; + lastAccessTime = other245.lastAccessTime; + sd = other245.sd; + parameters = other245.parameters; + privileges = other245.privileges; + __isset = other245.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -5863,14 +6019,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size245; - ::apache::thrift::protocol::TType _etype248; - xfer += iprot->readListBegin(_etype248, _size245); - this->values.resize(_size245); - uint32_t _i249; - for (_i249 = 0; _i249 < _size245; ++_i249) + uint32_t _size246; + ::apache::thrift::protocol::TType _etype249; + xfer += iprot->readListBegin(_etype249, _size246); + this->values.resize(_size246); + uint32_t _i250; + for (_i250 = 0; _i250 < _size246; ++_i250) { - xfer += iprot->readString(this->values[_i249]); + xfer += iprot->readString(this->values[_i250]); } xfer += iprot->readListEnd(); } @@ -5907,17 +6063,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size250; - ::apache::thrift::protocol::TType _ktype251; - ::apache::thrift::protocol::TType _vtype252; - xfer += iprot->readMapBegin(_ktype251, _vtype252, _size250); - uint32_t _i254; - for (_i254 = 0; _i254 < _size250; ++_i254) + uint32_t _size251; + ::apache::thrift::protocol::TType _ktype252; + ::apache::thrift::protocol::TType _vtype253; + xfer += iprot->readMapBegin(_ktype252, _vtype253, _size251); + uint32_t _i255; + for (_i255 = 0; _i255 < _size251; ++_i255) { - std::string _key255; - xfer += iprot->readString(_key255); - std::string& _val256 = this->parameters[_key255]; - xfer += iprot->readString(_val256); + std::string _key256; + xfer += iprot->readString(_key256); + std::string& _val257 = this->parameters[_key256]; + xfer += iprot->readString(_val257); } xfer += iprot->readMapEnd(); } @@ -5954,10 +6110,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 _iter257; - for (_iter257 = this->values.begin(); _iter257 != this->values.end(); ++_iter257) + std::vector<std::string> ::const_iterator _iter258; + for (_iter258 = this->values.begin(); _iter258 != this->values.end(); ++_iter258) { - xfer += oprot->writeString((*_iter257)); + xfer += oprot->writeString((*_iter258)); } xfer += oprot->writeListEnd(); } @@ -5978,11 +6134,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 _iter258; - for (_iter258 = this->parameters.begin(); _iter258 != this->parameters.end(); ++_iter258) + std::map<std::string, std::string> ::const_iterator _iter259; + for (_iter259 = this->parameters.begin(); _iter259 != this->parameters.end(); ++_iter259) { - xfer += oprot->writeString(_iter258->first); - xfer += oprot->writeString(_iter258->second); + xfer += oprot->writeString(_iter259->first); + xfer += oprot->writeString(_iter259->second); } xfer += oprot->writeMapEnd(); } @@ -6009,16 +6165,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other259) { - values = other259.values; - createTime = other259.createTime; - lastAccessTime = other259.lastAccessTime; - relativePath = other259.relativePath; - parameters = other259.parameters; - privileges = other259.privileges; - __isset = other259.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other260) { +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other260) { values = other260.values; createTime = other260.createTime; lastAccessTime = other260.lastAccessTime; @@ -6026,6 +6173,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe parameters = other260.parameters; privileges = other260.privileges; __isset = other260.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other261) { + values = other261.values; + createTime = other261.createTime; + lastAccessTime = other261.lastAccessTime; + relativePath = other261.relativePath; + parameters = other261.parameters; + privileges = other261.privileges; + __isset = other261.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -6078,14 +6234,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size261; - ::apache::thrift::protocol::TType _etype264; - xfer += iprot->readListBegin(_etype264, _size261); - this->partitions.resize(_size261); - uint32_t _i265; - for (_i265 = 0; _i265 < _size261; ++_i265) + uint32_t _size262; + ::apache::thrift::protocol::TType _etype265; + xfer += iprot->readListBegin(_etype265, _size262); + this->partitions.resize(_size262); + uint32_t _i266; + for (_i266 = 0; _i266 < _size262; ++_i266) { - xfer += this->partitions[_i265].read(iprot); + xfer += this->partitions[_i266].read(iprot); } xfer += iprot->readListEnd(); } @@ -6122,10 +6278,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 _iter266; - for (_iter266 = this->partitions.begin(); _iter266 != this->partitions.end(); ++_iter266) + std::vector<PartitionWithoutSD> ::const_iterator _iter267; + for (_iter267 = this->partitions.begin(); _iter267 != this->partitions.end(); ++_iter267) { - xfer += (*_iter266).write(oprot); + xfer += (*_iter267).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6147,15 +6303,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other267) { - partitions = other267.partitions; - sd = other267.sd; - __isset = other267.__isset; -} -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other268) { +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other268) { partitions = other268.partitions; sd = other268.sd; __isset = other268.__isset; +} +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other269) { + partitions = other269.partitions; + sd = other269.sd; + __isset = other269.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -6200,14 +6356,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size269; - ::apache::thrift::protocol::TType _etype272; - xfer += iprot->readListBegin(_etype272, _size269); - this->partitions.resize(_size269); - uint32_t _i273; - for (_i273 = 0; _i273 < _size269; ++_i273) + uint32_t _size270; + ::apache::thrift::protocol::TType _etype273; + xfer += iprot->readListBegin(_etype273, _size270); + this->partitions.resize(_size270); + uint32_t _i274; + for (_i274 = 0; _i274 < _size270; ++_i274) { - xfer += this->partitions[_i273].read(iprot); + xfer += this->partitions[_i274].read(iprot); } xfer += iprot->readListEnd(); } @@ -6236,10 +6392,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 _iter274; - for (_iter274 = this->partitions.begin(); _iter274 != this->partitions.end(); ++_iter274) + std::vector<Partition> ::const_iterator _iter275; + for (_iter275 = this->partitions.begin(); _iter275 != this->partitions.end(); ++_iter275) { - xfer += (*_iter274).write(oprot); + xfer += (*_iter275).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6256,13 +6412,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other275) { - partitions = other275.partitions; - __isset = other275.__isset; -} -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other276) { +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other276) { partitions = other276.partitions; __isset = other276.__isset; +} +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other277) { + partitions = other277.partitions; + __isset = other277.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -6414,21 +6570,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other277) { - dbName = other277.dbName; - tableName = other277.tableName; - rootPath = other277.rootPath; - sharedSDPartitionSpec = other277.sharedSDPartitionSpec; - partitionList = other277.partitionList; - __isset = other277.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other278) { +PartitionSpec::PartitionSpec(const PartitionSpec& other278) { dbName = other278.dbName; tableName = other278.tableName; rootPath = other278.rootPath; sharedSDPartitionSpec = other278.sharedSDPartitionSpec; partitionList = other278.partitionList; __isset = other278.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other279) { + dbName = other279.dbName; + tableName = other279.tableName; + rootPath = other279.rootPath; + sharedSDPartitionSpec = other279.sharedSDPartitionSpec; + partitionList = other279.partitionList; + __isset = other279.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -6574,19 +6730,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other279) { - numTrues = other279.numTrues; - numFalses = other279.numFalses; - numNulls = other279.numNulls; - bitVectors = other279.bitVectors; - __isset = other279.__isset; -} -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other280) { +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other280) { numTrues = other280.numTrues; numFalses = other280.numFalses; numNulls = other280.numNulls; bitVectors = other280.bitVectors; __isset = other280.__isset; +} +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other281) { + numTrues = other281.numTrues; + numFalses = other281.numFalses; + numNulls = other281.numNulls; + bitVectors = other281.bitVectors; + __isset = other281.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -6749,21 +6905,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other281) { - lowValue = other281.lowValue; - highValue = other281.highValue; - numNulls = other281.numNulls; - numDVs = other281.numDVs; - bitVectors = other281.bitVectors; - __isset = other281.__isset; -} -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other282) { +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other282) { lowValue = other282.lowValue; highValue = other282.highValue; numNulls = other282.numNulls; numDVs = other282.numDVs; bitVectors = other282.bitVectors; __isset = other282.__isset; +} +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other283) { + lowValue = other283.lowValue; + highValue = other283.highValue; + numNulls = other283.numNulls; + numDVs = other283.numDVs; + bitVectors = other283.bitVectors; + __isset = other283.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -6927,21 +7083,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other283) { - lowValue = other283.lowValue; - highValue = other283.highValue; - numNulls = other283.numNulls; - numDVs = other283.numDVs; - bitVectors = other283.bitVectors; - __isset = other283.__isset; -} -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other284) { +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other284) { lowValue = other284.lowValue; highValue = other284.highValue; numNulls = other284.numNulls; numDVs = other284.numDVs; bitVectors = other284.bitVectors; __isset = other284.__isset; +} +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other285) { + lowValue = other285.lowValue; + highValue = other285.highValue; + numNulls = other285.numNulls; + numDVs = other285.numDVs; + bitVectors = other285.bitVectors; + __isset = other285.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -7107,21 +7263,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other285) { - maxColLen = other285.maxColLen; - avgColLen = other285.avgColLen; - numNulls = other285.numNulls; - numDVs = other285.numDVs; - bitVectors = other285.bitVectors; - __isset = other285.__isset; -} -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other286) { +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other286) { maxColLen = other286.maxColLen; avgColLen = other286.avgColLen; numNulls = other286.numNulls; numDVs = other286.numDVs; bitVectors = other286.bitVectors; __isset = other286.__isset; +} +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other287) { + maxColLen = other287.maxColLen; + avgColLen = other287.avgColLen; + numNulls = other287.numNulls; + numDVs = other287.numDVs; + bitVectors = other287.bitVectors; + __isset = other287.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -7267,19 +7423,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other287) { - maxColLen = other287.maxColLen; - avgColLen = other287.avgColLen; - numNulls = other287.numNulls; - bitVectors = other287.bitVectors; - __isset = other287.__isset; -} -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other288) { +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other288) { maxColLen = other288.maxColLen; avgColLen = other288.avgColLen; numNulls = other288.numNulls; bitVectors = other288.bitVectors; __isset = other288.__isset; +} +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other289) { + maxColLen = other289.maxColLen; + avgColLen = other289.avgColLen; + numNulls = other289.numNulls; + bitVectors = other289.bitVectors; + __isset = other289.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -7384,13 +7540,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other289) { - unscaled = other289.unscaled; - scale = other289.scale; -} -Decimal& Decimal::operator=(const Decimal& other290) { +Decimal::Decimal(const Decimal& other290) { unscaled = other290.unscaled; scale = other290.scale; +} +Decimal& Decimal::operator=(const Decimal& other291) { + unscaled = other291.unscaled; + scale = other291.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7551,21 +7707,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other291) { - lowValue = other291.lowValue; - highValue = other291.highValue; - numNulls = other291.numNulls; - numDVs = other291.numDVs; - bitVectors = other291.bitVectors; - __isset = other291.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other292) { +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other292) { lowValue = other292.lowValue; highValue = other292.highValue; numNulls = other292.numNulls; numDVs = other292.numDVs; bitVectors = other292.bitVectors; __isset = other292.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other293) { + lowValue = other293.lowValue; + highValue = other293.highValue; + numNulls = other293.numNulls; + numDVs = other293.numDVs; + bitVectors = other293.bitVectors; + __isset = other293.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7651,11 +7807,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other293) { - daysSinceEpoch = other293.daysSinceEpoch; -} -Date& Date::operator=(const Date& other294) { +Date::Date(const Date& other294) { daysSinceEpoch = other294.daysSinceEpoch; +} +Date& Date::operator=(const Date& other295) { + daysSinceEpoch = other295.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7815,21 +7971,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other295) { - lowValue = other295.lowValue; - highValue = other295.highValue; - numNulls = other295.numNulls; - numDVs = other295.numDVs; - bitVectors = other295.bitVectors; - __isset = other295.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other296) { +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other296) { lowValue = other296.lowValue; highValue = other296.highValue; numNulls = other296.numNulls; numDVs = other296.numDVs; bitVectors = other296.bitVectors; __isset = other296.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other297) { + lowValue = other297.lowValue; + highValue = other297.highValue; + numNulls = other297.numNulls; + numDVs = other297.numDVs; + bitVectors = other297.bitVectors; + __isset = other297.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -8015,17 +8171,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other297) { - booleanStats = other297.booleanStats; - longStats = other297.longStats; - doubleStats = other297.doubleStats; - stringStats = other297.stringStats; - binaryStats = other297.binaryStats; - decimalStats = other297.decimalStats; - dateStats = other297.dateStats; - __isset = other297.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other298) { +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other298) { booleanStats = other298.booleanStats; longStats = other298.longStats; doubleStats = other298.doubleStats; @@ -8034,6 +8180,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData decimalStats = other298.decimalStats; dateStats = other298.dateStats; __isset = other298.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other299) { + booleanStats = other299.booleanStats; + longStats = other299.longStats; + doubleStats = other299.doubleStats; + stringStats = other299.stringStats; + binaryStats = other299.binaryStats; + decimalStats = other299.decimalStats; + dateStats = other299.dateStats; + __isset = other299.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -8161,15 +8317,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other299) { - colName = other299.colName; - colType = other299.colType; - statsData = other299.statsData; -} -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other300) { +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other300) { colName = other300.colName; colType = other300.colType; statsData = other300.statsData; +} +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other301) { + colName = other301.colName; + colType = other301.colType; + statsData = other301.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -8332,21 +8488,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other301) { - isTblLevel = other301.isTblLevel; - dbName = other301.dbName; - tableName = other301.tableName; - partName = other301.partName; - lastAnalyzed = other301.lastAnalyzed; - __isset = other301.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other302) { +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other302) { isTblLevel = other302.isTblLevel; dbName = other302.dbName; tableName = other302.tableName; partName = other302.partName; lastAnalyzed = other302.lastAnalyzed; __isset = other302.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other303) { + isTblLevel = other303.isTblLevel; + dbName = other303.dbName; + tableName = other303.tableName; + partName = other303.partName; + lastAnalyzed = other303.lastAnalyzed; + __isset = other303.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -8408,14 +8564,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size303; - ::apache::thrift::protocol::TType _etype306; - xfer += iprot->readListBegin(_etype306, _size303); - this->statsObj.resize(_size303); - uint32_t _i307; - for (_i307 = 0; _i307 < _size303; ++_i307) + uint32_t _size304; + ::apache::thrift::protocol::TType _etype307; + xfer += iprot->readListBegin(_etype307, _size304); + this->statsObj.resize(_size304); + uint32_t _i308; + for (_i308 = 0; _i308 < _size304; ++_i308) { - xfer += this->statsObj[_i307].read(iprot); + xfer += this->statsObj[_i308].read(iprot); } xfer += iprot->readListEnd(); } @@ -8452,10 +8608,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 _iter308; - for (_iter308 = this->statsObj.begin(); _iter308 != this->statsObj.end(); ++_iter308) + std::vector<ColumnStatisticsObj> ::const_iterator _iter309; + for (_iter309 = this->statsObj.begin(); _iter309 != this->statsObj.end(); ++_iter309) { - xfer += (*_iter308).write(oprot); + xfer += (*_iter309).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8472,13 +8628,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other309) { - statsDesc = other309.statsDesc; - statsObj = other309.statsObj; -} -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other310) { +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other310) { statsDesc = other310.statsDesc; statsObj = other310.statsObj; +} +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other311) { + statsDesc = other311.statsDesc; + statsObj = other311.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8529,14 +8685,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size311; - ::apache::thrift::protocol::TType _etype314; - xfer += iprot->readListBegin(_etype314, _size311); - this->colStats.resize(_size311); - uint32_t _i315; - for (_i315 = 0; _i315 < _size311; ++_i315) + uint32_t _size312; + ::apache::thrift::protocol::TType _etype315; + xfer += iprot->readListBegin(_etype315, _size312); + this->colStats.resize(_size312); + uint32_t _i316; + for (_i316 = 0; _i316 < _size312; ++_i316) { - xfer += this->colStats[_i315].read(iprot); + xfer += this->colStats[_i316].read(iprot); } xfer += iprot->readListEnd(); } @@ -8577,10 +8733,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 _iter316; - for (_iter316 = this->colStats.begin(); _iter316 != this->colStats.end(); ++_iter316) + std::vector<ColumnStatisticsObj> ::const_iterator _iter317; + for (_iter317 = this->colStats.begin(); _iter317 != this->colStats.end(); ++_iter317) { - xfer += (*_iter316).write(oprot); + xfer += (*_iter317).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8601,13 +8757,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other317) { - colStats = other317.colStats; - partsFound = other317.partsFound; -} -AggrStats& AggrStats::operator=(const AggrStats& other318) { +AggrStats::AggrStats(const AggrStats& other318) { colStats = other318.colStats; partsFound = other318.partsFound; +} +AggrStats& AggrStats::operator=(const AggrStats& other319) { + colStats = other319.colStats; + partsFound = other319.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8658,14 +8814,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* 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(); } @@ -8704,10 +8860,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 _iter324; - for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); ++_iter324) + std::vector<ColumnStatistics> ::const_iterator _iter325; + for (_iter325 = this->colStats.begin(); _iter325 != this->colStats.end(); ++_iter325) { - xfer += (*_iter324).write(oprot); + xfer += (*_iter325).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8730,15 +8886,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other325) { - colStats = other325.colStats; - needMerge = other325.needMerge; - __isset = other325.__isset; -} -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other326) { +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other326) { colStats = other326.colStats; needMerge = other326.needMerge; __isset = other326.__isset; +} +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other327) { + colStats = other327.colStats; + needMerge = other327.needMerge; + __isset = other327.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -8787,14 +8943,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size327; - ::apache::thrift::protocol::TType _etype330; - xfer += iprot->readListBegin(_etype330, _size327); - this->fieldSchemas.resize(_size327); - uint32_t _i331; - for (_i331 = 0; _i331 < _size327; ++_i331) + uint32_t _size328; + ::apache::thrift::protocol::TType _etype331; + xfer += iprot->readListBegin(_etype331, _size328); + this->fieldSchemas.resize(_size328); + uint32_t _i332; + for (_i332 = 0; _i332 < _size328; ++_i332) { - xfer += this->fieldSchemas[_i331].read(iprot); + xfer += this->fieldSchemas[_i332].read(iprot); } xfer += iprot->readListEnd(); } @@ -8807,17 +8963,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size332; - ::apache::thrift::protocol::TType _ktype333; - ::apache::thrift::protocol::TType _vtype334; - xfer += iprot->readMapBegin(_ktype333, _vtype334, _size332); - uint32_t _i336; - for (_i336 = 0; _i336 < _size332; ++_i336) + uint32_t _size333; + ::apache::thrift::protocol::TType _ktype334; + ::apache::thrift::protocol::TType _vtype335; + xfer += iprot->readMapBegin(_ktype334, _vtype335, _size333); + uint32_t _i337; + for (_i337 = 0; _i337 < _size333; ++_i337) { - std::string _key337; - xfer += iprot->readString(_key337); - std::string& _val338 = this->properties[_key337]; - xfer += iprot->readString(_val338); + std::string _key338; + xfer += iprot->readString(_key338); + std::string& _val339 = this->properties[_key338]; + xfer += iprot->readString(_val339); } xfer += iprot->readMapEnd(); } @@ -8846,10 +9002,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 _iter339; - for (_iter339 = this->fieldSchemas.begin(); _iter339 != this->fieldSchemas.end(); ++_iter339) + std::vector<FieldSchema> ::const_iterator _iter340; + for (_iter340 = this->fieldSchemas.begin(); _iter340 != this->fieldSchemas.end(); ++_iter340) { - xfer += (*_iter339).write(oprot); + xfer += (*_iter340).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8858,11 +9014,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 _iter340; - for (_iter340 = this->properties.begin(); _iter340 != this->properties.end(); ++_iter340) + std::map<std::string, std::string> ::const_iterator _iter341; + for (_iter341 = this->properties.begin(); _iter341 != this->properties.end(); ++_iter341) { - xfer += oprot->writeString(_iter340->first); - xfer += oprot->writeString(_iter340->second); + xfer += oprot->writeString(_iter341->first); + xfer += oprot->writeString(_iter341->second); } xfer += oprot->writeMapEnd(); } @@ -8880,15 +9036,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other341) { - fieldSchemas = other341.fieldSchemas; - properties = other341.properties; - __isset = other341.__isset; -} -Schema& Schema::operator=(const Schema& other342) { +Schema::Schema(const Schema& other342) { fieldSchemas = other342.fieldSchemas; properties = other342.properties; __isset = other342.__isset; +} +Schema& Schema::operator=(const Schema& other343) { + fieldSchemas = other343.fieldSchemas; + properties = other343.properties; + __isset = other343.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -8933,17 +9089,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size343; - ::apache::thrift::protocol::TType _ktype344; - ::apache::thrift::protocol::TType _vtype345; - xfer += iprot->readMapBegin(_ktype344, _vtype345, _size343); - uint32_t _i347; - for (_i347 = 0; _i347 < _size343; ++_i347) + uint32_t _size344; + ::apache::thrift::protocol::TType _ktype345; + ::apache::thrift::protocol::TType _vtype346; + xfer += iprot->readMapBegin(_ktype345, _vtype346, _size344); + uint32_t _i348; + for (_i348 = 0; _i348 < _size344; ++_i348) { - std::string _key348; - xfer += iprot->readString(_key348); - std::string& _val349 = this->properties[_key348]; - xfer += iprot->readString(_val349); + std::string _key349; + xfer += iprot->readString(_key349); + std::string& _val350 = this->properties[_key349]; + xfer += iprot->readString(_val350); } xfer += iprot->readMapEnd(); } @@ -8972,11 +9128,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 _iter350; - for (_iter350 = this->properties.begin(); _iter350 != this->properties.end(); ++_iter350) + std::map<std::string, std::string> ::const_iterator _iter351; + for (_iter351 = this->properties.begin(); _iter351 != this->properties.end(); ++_iter351) { - xfer += oprot->writeString(_iter350->first); - xfer += oprot->writeString(_iter350->second); + xfer += oprot->writeString(_iter351->first); + xfer += oprot->writeString(_iter351->second); } xfer += oprot->writeMapEnd(); } @@ -8993,13 +9149,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other351) { - properties = other351.properties; - __isset = other351.__isset; -} -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other352) { +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other352) { properties = other352.properties; __isset = other352.__isset; +} +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other353) { + properties = other353.properties; + __isset = other353.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -9101,13 +9257,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other353) { - db_name = other353.db_name; - tbl_name = other353.tbl_name; -} -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other354) { +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other354) { db_name = other354.db_name; tbl_name = other354.tbl_name; +} +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other355) { + db_name = other355.db_name; + tbl_name = other355.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -9153,14 +9309,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size355; - ::apache::thrift::protocol::TType _etype358; - xfer += iprot->readListBegin(_etype358, _size355); - this->primaryKeys.resize(_size355); - uint32_t _i359; - for (_i359 = 0; _i359 < _size355; ++_i359) + uint32_t _size356; + ::apache::thrift::protocol::TType _etype359; + xfer += iprot->readListBegin(_etype359, _size356); + this->primaryKeys.resize(_size356); + uint32_t _i360; + for (_i360 = 0; _i360 < _size356; ++_i360) { - xfer += this->primaryKeys[_i359].read(iprot); + xfer += this->primaryKeys[_i360].read(iprot); } xfer += iprot->readListEnd(); } @@ -9191,10 +9347,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 _iter360; - for (_iter360 = this->primaryKeys.begin(); _iter360 != this->primaryKeys.end(); ++_iter360) + std::vector<SQLPrimaryKey> ::const_iterator _iter361; + for (_iter361 = this->primaryKeys.begin(); _iter361 != this->primaryKeys.end(); ++_iter361) { - xfer += (*_iter360).write(oprot); + xfer += (*_iter361).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9210,11 +9366,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other361) { - primaryKeys = other361.primaryKeys; -} -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other362) { +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other362) { primaryKeys = other362.primaryKeys; +} +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other363) { + primaryKeys = other363.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -9345,19 +9501,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other363) { - parent_db_name = other363.parent_db_name; - parent_tbl_name = other363.parent_tbl_name; - foreign_db_name = other363.foreign_db_name; - foreign_tbl_name = other363.foreign_tbl_name; - __isset = other363.__isset; -} -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other364) { +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other364) { parent_db_name = other364.parent_db_name; parent_tbl_name = other364.parent_tbl_name; foreign_db_name = other364.foreign_db_name; foreign_tbl_name = other364.foreign_tbl_name; __isset = other364.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other365) { + parent_db_name = other365.parent_db_name; + parent_tbl_name = other365.parent_tbl_name; + foreign_db_name = other365.foreign_db_name; + foreign_tbl_name = other365.foreign_tbl_name; + __isset = other365.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -9405,14 +9561,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size365; - ::apache::thrift::protocol::TType _etype368; - xfer += iprot->readListBegin(_etype368, _size365); - this->foreignKeys.resize(_size365); - uint32_t _i369; - for (_i369 = 0; _i369 < _size365; ++_i369) + uint32_t _size366; + ::apache::thrift::protocol::TType _etype369; + xfer += iprot->readListBegin(_etype369, _size366); + this->foreignKeys.resize(_size366); + uint32_t _i370; + for (_i370 = 0; _i370 < _size366; ++_i370) { - xfer += this->foreignKeys[_i369].read(iprot); + xfer += this->foreignKeys[_i370].read(iprot); } xfer += iprot->readListEnd(); } @@ -9443,10 +9599,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size())); - std::vector<SQLForeignKey> ::const_iterator _iter370; - for (_iter370 = this->foreignKeys.begin(); _iter370 != this->foreignKeys.end(); ++_iter370) + std::vector<SQLForeignKey> ::const_iterator _iter371; + for (_iter371 = this->foreignKeys.begin(); _iter371 != this->foreignKeys.end(); ++_iter371) { - xfer += (*_iter370).write(oprot); + xfer += (*_iter371).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9462,11 +9618,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other371) { - foreignKeys = other371.foreignKeys; -} -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other372) { +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other372) { foreignKeys = other372.foreignKeys; +} +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other373) { + foreignKeys = other373.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9568,13 +9724,13 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other373) { - db_name = other373.db_name; - tbl_name = other373.tbl_name; -} -UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other374) { +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other374) { db_name = other374.db_name; tbl_name = other374.tbl_name; +} +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other375) { + db_name = other375.db_name; + tbl_name = other375.tbl_name; return *this; } void UniqueConstraintsRequest::printTo(std::ostream& out) const { @@ -9620,14 +9776,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size375; - ::apache::thrift::protocol::TType _etype378; - xfer += iprot->readListBegin(_etype378, _size375); - this->uniqueConstraints.resize(_size375); - uint32_t _i379; - for (_i379 = 0; _i379 < _size375; ++_i379) + uint32_t _size376; + ::apache::thrift::protocol::TType _etype379; + xfer += iprot->readListBegin(_etype379, _size376); + this->uniqueConstraints.resize(_size376); + uint32_t _i380; + for (_i380 = 0; _i380 < _size376; ++_i380) { - xfer += this->uniqueConstraints[_i379].read(iprot); + xfer += this->uniqueConstraints[_i380].read(iprot); } xfer += iprot->readListEnd(); } @@ -9658,10 +9814,10 @@ uint32_t UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraints.size())); - std::vector<SQLUniqueConstraint> ::const_iterator _iter380; - for (_iter380 = this->uniqueConstraints.begin(); _iter380 != this->uniqueConstraints.end(); ++_iter380) + std::vector<SQLUniqueConstraint> ::const_iterator _iter381; + for (_iter381 = this->uniqueConstraints.begi
<TRUNCATED>