You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ga...@apache.org on 2018/03/12 23:55:54 UTC
[14/18] hive git commit: HIVE-17990 Add Thrift and DB storage for
Schema Registry objects (Alan Gates, reviewed by Thejas Nair)
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>