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 2017/12/07 17:54:28 UTC
[46/50] [abbrv] hive git commit: HIVE-17990 Add Thrift and DB storage
for Schema Registry objects
http://git-wip-us.apache.org/repos/asf/hive/blob/bd212257/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 913e3cc..f026ff9 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
};
@@ -3999,6 +4065,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);
@@ -4059,6 +4145,40 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
xfer += iprot->skip(ftype);
}
break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->description);
+ this->__isset.description = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->serializerClass);
+ this->__isset.serializerClass = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->deserializerClass);
+ this->__isset.deserializerClass = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast144;
+ xfer += iprot->readI32(ecast144);
+ this->serdeType = (SerdeType::type)ecast144;
+ this->__isset.serdeType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@ -4087,16 +4207,36 @@ uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter144;
- for (_iter144 = this->parameters.begin(); _iter144 != this->parameters.end(); ++_iter144)
+ std::map<std::string, std::string> ::const_iterator _iter145;
+ for (_iter145 = this->parameters.begin(); _iter145 != this->parameters.end(); ++_iter145)
{
- xfer += oprot->writeString(_iter144->first);
- xfer += oprot->writeString(_iter144->second);
+ xfer += oprot->writeString(_iter145->first);
+ xfer += oprot->writeString(_iter145->second);
}
xfer += oprot->writeMapEnd();
}
xfer += oprot->writeFieldEnd();
+ if (this->__isset.description) {
+ xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->description);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.serializerClass) {
+ xfer += oprot->writeFieldBegin("serializerClass", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->serializerClass);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.deserializerClass) {
+ xfer += oprot->writeFieldBegin("deserializerClass", ::apache::thrift::protocol::T_STRING, 6);
+ xfer += oprot->writeString(this->deserializerClass);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.serdeType) {
+ xfer += oprot->writeFieldBegin("serdeType", ::apache::thrift::protocol::T_I32, 7);
+ xfer += oprot->writeI32((int32_t)this->serdeType);
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
@@ -4107,20 +4247,32 @@ void swap(SerDeInfo &a, SerDeInfo &b) {
swap(a.name, b.name);
swap(a.serializationLib, b.serializationLib);
swap(a.parameters, b.parameters);
+ swap(a.description, b.description);
+ swap(a.serializerClass, b.serializerClass);
+ swap(a.deserializerClass, b.deserializerClass);
+ swap(a.serdeType, b.serdeType);
swap(a.__isset, b.__isset);
}
-SerDeInfo::SerDeInfo(const SerDeInfo& other145) {
- name = other145.name;
- serializationLib = other145.serializationLib;
- parameters = other145.parameters;
- __isset = other145.__isset;
-}
-SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other146) {
+SerDeInfo::SerDeInfo(const SerDeInfo& other146) {
name = other146.name;
serializationLib = other146.serializationLib;
parameters = other146.parameters;
+ description = other146.description;
+ serializerClass = other146.serializerClass;
+ deserializerClass = other146.deserializerClass;
+ serdeType = other146.serdeType;
__isset = other146.__isset;
+}
+SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other147) {
+ name = other147.name;
+ serializationLib = other147.serializationLib;
+ parameters = other147.parameters;
+ description = other147.description;
+ serializerClass = other147.serializerClass;
+ deserializerClass = other147.deserializerClass;
+ serdeType = other147.serdeType;
+ __isset = other147.__isset;
return *this;
}
void SerDeInfo::printTo(std::ostream& out) const {
@@ -4129,6 +4281,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 << ")";
}
@@ -4219,15 +4375,15 @@ void swap(Order &a, Order &b) {
swap(a.__isset, b.__isset);
}
-Order::Order(const Order& other147) {
- col = other147.col;
- order = other147.order;
- __isset = other147.__isset;
-}
-Order& Order::operator=(const Order& other148) {
+Order::Order(const Order& other148) {
col = other148.col;
order = other148.order;
__isset = other148.__isset;
+}
+Order& Order::operator=(const Order& other149) {
+ col = other149.col;
+ order = other149.order;
+ __isset = other149.__isset;
return *this;
}
void Order::printTo(std::ostream& out) const {
@@ -4280,14 +4436,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->skewedColNames.clear();
- uint32_t _size149;
- ::apache::thrift::protocol::TType _etype152;
- xfer += iprot->readListBegin(_etype152, _size149);
- this->skewedColNames.resize(_size149);
- uint32_t _i153;
- for (_i153 = 0; _i153 < _size149; ++_i153)
+ uint32_t _size150;
+ ::apache::thrift::protocol::TType _etype153;
+ xfer += iprot->readListBegin(_etype153, _size150);
+ this->skewedColNames.resize(_size150);
+ uint32_t _i154;
+ for (_i154 = 0; _i154 < _size150; ++_i154)
{
- xfer += iprot->readString(this->skewedColNames[_i153]);
+ xfer += iprot->readString(this->skewedColNames[_i154]);
}
xfer += iprot->readListEnd();
}
@@ -4300,23 +4456,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->skewedColValues.clear();
- uint32_t _size154;
- ::apache::thrift::protocol::TType _etype157;
- xfer += iprot->readListBegin(_etype157, _size154);
- this->skewedColValues.resize(_size154);
- uint32_t _i158;
- for (_i158 = 0; _i158 < _size154; ++_i158)
+ uint32_t _size155;
+ ::apache::thrift::protocol::TType _etype158;
+ xfer += iprot->readListBegin(_etype158, _size155);
+ this->skewedColValues.resize(_size155);
+ uint32_t _i159;
+ for (_i159 = 0; _i159 < _size155; ++_i159)
{
{
- this->skewedColValues[_i158].clear();
- uint32_t _size159;
- ::apache::thrift::protocol::TType _etype162;
- xfer += iprot->readListBegin(_etype162, _size159);
- this->skewedColValues[_i158].resize(_size159);
- uint32_t _i163;
- for (_i163 = 0; _i163 < _size159; ++_i163)
+ this->skewedColValues[_i159].clear();
+ uint32_t _size160;
+ ::apache::thrift::protocol::TType _etype163;
+ xfer += iprot->readListBegin(_etype163, _size160);
+ this->skewedColValues[_i159].resize(_size160);
+ uint32_t _i164;
+ for (_i164 = 0; _i164 < _size160; ++_i164)
{
- xfer += iprot->readString(this->skewedColValues[_i158][_i163]);
+ xfer += iprot->readString(this->skewedColValues[_i159][_i164]);
}
xfer += iprot->readListEnd();
}
@@ -4332,29 +4488,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->skewedColValueLocationMaps.clear();
- uint32_t _size164;
- ::apache::thrift::protocol::TType _ktype165;
- ::apache::thrift::protocol::TType _vtype166;
- xfer += iprot->readMapBegin(_ktype165, _vtype166, _size164);
- uint32_t _i168;
- for (_i168 = 0; _i168 < _size164; ++_i168)
+ uint32_t _size165;
+ ::apache::thrift::protocol::TType _ktype166;
+ ::apache::thrift::protocol::TType _vtype167;
+ xfer += iprot->readMapBegin(_ktype166, _vtype167, _size165);
+ uint32_t _i169;
+ for (_i169 = 0; _i169 < _size165; ++_i169)
{
- std::vector<std::string> _key169;
+ std::vector<std::string> _key170;
{
- _key169.clear();
- uint32_t _size171;
- ::apache::thrift::protocol::TType _etype174;
- xfer += iprot->readListBegin(_etype174, _size171);
- _key169.resize(_size171);
- uint32_t _i175;
- for (_i175 = 0; _i175 < _size171; ++_i175)
+ _key170.clear();
+ uint32_t _size172;
+ ::apache::thrift::protocol::TType _etype175;
+ xfer += iprot->readListBegin(_etype175, _size172);
+ _key170.resize(_size172);
+ uint32_t _i176;
+ for (_i176 = 0; _i176 < _size172; ++_i176)
{
- xfer += iprot->readString(_key169[_i175]);
+ xfer += iprot->readString(_key170[_i176]);
}
xfer += iprot->readListEnd();
}
- std::string& _val170 = this->skewedColValueLocationMaps[_key169];
- xfer += iprot->readString(_val170);
+ std::string& _val171 = this->skewedColValueLocationMaps[_key170];
+ xfer += iprot->readString(_val171);
}
xfer += iprot->readMapEnd();
}
@@ -4383,10 +4539,10 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColNames.size()));
- std::vector<std::string> ::const_iterator _iter176;
- for (_iter176 = this->skewedColNames.begin(); _iter176 != this->skewedColNames.end(); ++_iter176)
+ std::vector<std::string> ::const_iterator _iter177;
+ for (_iter177 = this->skewedColNames.begin(); _iter177 != this->skewedColNames.end(); ++_iter177)
{
- xfer += oprot->writeString((*_iter176));
+ xfer += oprot->writeString((*_iter177));
}
xfer += oprot->writeListEnd();
}
@@ -4395,15 +4551,15 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->skewedColValues.size()));
- std::vector<std::vector<std::string> > ::const_iterator _iter177;
- for (_iter177 = this->skewedColValues.begin(); _iter177 != this->skewedColValues.end(); ++_iter177)
+ std::vector<std::vector<std::string> > ::const_iterator _iter178;
+ for (_iter178 = this->skewedColValues.begin(); _iter178 != this->skewedColValues.end(); ++_iter178)
{
{
- xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter177).size()));
- std::vector<std::string> ::const_iterator _iter178;
- for (_iter178 = (*_iter177).begin(); _iter178 != (*_iter177).end(); ++_iter178)
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter178).size()));
+ std::vector<std::string> ::const_iterator _iter179;
+ for (_iter179 = (*_iter178).begin(); _iter179 != (*_iter178).end(); ++_iter179)
{
- xfer += oprot->writeString((*_iter178));
+ xfer += oprot->writeString((*_iter179));
}
xfer += oprot->writeListEnd();
}
@@ -4415,19 +4571,19 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColValueLocationMaps.size()));
- std::map<std::vector<std::string> , std::string> ::const_iterator _iter179;
- for (_iter179 = this->skewedColValueLocationMaps.begin(); _iter179 != this->skewedColValueLocationMaps.end(); ++_iter179)
+ std::map<std::vector<std::string> , std::string> ::const_iterator _iter180;
+ for (_iter180 = this->skewedColValueLocationMaps.begin(); _iter180 != this->skewedColValueLocationMaps.end(); ++_iter180)
{
{
- xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter179->first.size()));
- std::vector<std::string> ::const_iterator _iter180;
- for (_iter180 = _iter179->first.begin(); _iter180 != _iter179->first.end(); ++_iter180)
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter180->first.size()));
+ std::vector<std::string> ::const_iterator _iter181;
+ for (_iter181 = _iter180->first.begin(); _iter181 != _iter180->first.end(); ++_iter181)
{
- xfer += oprot->writeString((*_iter180));
+ xfer += oprot->writeString((*_iter181));
}
xfer += oprot->writeListEnd();
}
- xfer += oprot->writeString(_iter179->second);
+ xfer += oprot->writeString(_iter180->second);
}
xfer += oprot->writeMapEnd();
}
@@ -4446,17 +4602,17 @@ void swap(SkewedInfo &a, SkewedInfo &b) {
swap(a.__isset, b.__isset);
}
-SkewedInfo::SkewedInfo(const SkewedInfo& other181) {
- skewedColNames = other181.skewedColNames;
- skewedColValues = other181.skewedColValues;
- skewedColValueLocationMaps = other181.skewedColValueLocationMaps;
- __isset = other181.__isset;
-}
-SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other182) {
+SkewedInfo::SkewedInfo(const SkewedInfo& other182) {
skewedColNames = other182.skewedColNames;
skewedColValues = other182.skewedColValues;
skewedColValueLocationMaps = other182.skewedColValueLocationMaps;
__isset = other182.__isset;
+}
+SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other183) {
+ skewedColNames = other183.skewedColNames;
+ skewedColValues = other183.skewedColValues;
+ skewedColValueLocationMaps = other183.skewedColValueLocationMaps;
+ __isset = other183.__isset;
return *this;
}
void SkewedInfo::printTo(std::ostream& out) const {
@@ -4548,14 +4704,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->cols.clear();
- uint32_t _size183;
- ::apache::thrift::protocol::TType _etype186;
- xfer += iprot->readListBegin(_etype186, _size183);
- this->cols.resize(_size183);
- uint32_t _i187;
- for (_i187 = 0; _i187 < _size183; ++_i187)
+ uint32_t _size184;
+ ::apache::thrift::protocol::TType _etype187;
+ xfer += iprot->readListBegin(_etype187, _size184);
+ this->cols.resize(_size184);
+ uint32_t _i188;
+ for (_i188 = 0; _i188 < _size184; ++_i188)
{
- xfer += this->cols[_i187].read(iprot);
+ xfer += this->cols[_i188].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4616,14 +4772,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->bucketCols.clear();
- uint32_t _size188;
- ::apache::thrift::protocol::TType _etype191;
- xfer += iprot->readListBegin(_etype191, _size188);
- this->bucketCols.resize(_size188);
- uint32_t _i192;
- for (_i192 = 0; _i192 < _size188; ++_i192)
+ uint32_t _size189;
+ ::apache::thrift::protocol::TType _etype192;
+ xfer += iprot->readListBegin(_etype192, _size189);
+ this->bucketCols.resize(_size189);
+ uint32_t _i193;
+ for (_i193 = 0; _i193 < _size189; ++_i193)
{
- xfer += iprot->readString(this->bucketCols[_i192]);
+ xfer += iprot->readString(this->bucketCols[_i193]);
}
xfer += iprot->readListEnd();
}
@@ -4636,14 +4792,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->sortCols.clear();
- uint32_t _size193;
- ::apache::thrift::protocol::TType _etype196;
- xfer += iprot->readListBegin(_etype196, _size193);
- this->sortCols.resize(_size193);
- uint32_t _i197;
- for (_i197 = 0; _i197 < _size193; ++_i197)
+ uint32_t _size194;
+ ::apache::thrift::protocol::TType _etype197;
+ xfer += iprot->readListBegin(_etype197, _size194);
+ this->sortCols.resize(_size194);
+ uint32_t _i198;
+ for (_i198 = 0; _i198 < _size194; ++_i198)
{
- xfer += this->sortCols[_i197].read(iprot);
+ xfer += this->sortCols[_i198].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4656,17 +4812,17 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size198;
- ::apache::thrift::protocol::TType _ktype199;
- ::apache::thrift::protocol::TType _vtype200;
- xfer += iprot->readMapBegin(_ktype199, _vtype200, _size198);
- uint32_t _i202;
- for (_i202 = 0; _i202 < _size198; ++_i202)
+ uint32_t _size199;
+ ::apache::thrift::protocol::TType _ktype200;
+ ::apache::thrift::protocol::TType _vtype201;
+ xfer += iprot->readMapBegin(_ktype200, _vtype201, _size199);
+ uint32_t _i203;
+ for (_i203 = 0; _i203 < _size199; ++_i203)
{
- std::string _key203;
- xfer += iprot->readString(_key203);
- std::string& _val204 = this->parameters[_key203];
- xfer += iprot->readString(_val204);
+ std::string _key204;
+ xfer += iprot->readString(_key204);
+ std::string& _val205 = this->parameters[_key204];
+ xfer += iprot->readString(_val205);
}
xfer += iprot->readMapEnd();
}
@@ -4711,10 +4867,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->cols.size()));
- std::vector<FieldSchema> ::const_iterator _iter205;
- for (_iter205 = this->cols.begin(); _iter205 != this->cols.end(); ++_iter205)
+ std::vector<FieldSchema> ::const_iterator _iter206;
+ for (_iter206 = this->cols.begin(); _iter206 != this->cols.end(); ++_iter206)
{
- xfer += (*_iter205).write(oprot);
+ xfer += (*_iter206).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4747,10 +4903,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->bucketCols.size()));
- std::vector<std::string> ::const_iterator _iter206;
- for (_iter206 = this->bucketCols.begin(); _iter206 != this->bucketCols.end(); ++_iter206)
+ std::vector<std::string> ::const_iterator _iter207;
+ for (_iter207 = this->bucketCols.begin(); _iter207 != this->bucketCols.end(); ++_iter207)
{
- xfer += oprot->writeString((*_iter206));
+ xfer += oprot->writeString((*_iter207));
}
xfer += oprot->writeListEnd();
}
@@ -4759,10 +4915,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sortCols.size()));
- std::vector<Order> ::const_iterator _iter207;
- for (_iter207 = this->sortCols.begin(); _iter207 != this->sortCols.end(); ++_iter207)
+ std::vector<Order> ::const_iterator _iter208;
+ for (_iter208 = this->sortCols.begin(); _iter208 != this->sortCols.end(); ++_iter208)
{
- xfer += (*_iter207).write(oprot);
+ xfer += (*_iter208).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4771,11 +4927,11 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter208;
- for (_iter208 = this->parameters.begin(); _iter208 != this->parameters.end(); ++_iter208)
+ std::map<std::string, std::string> ::const_iterator _iter209;
+ for (_iter209 = this->parameters.begin(); _iter209 != this->parameters.end(); ++_iter209)
{
- xfer += oprot->writeString(_iter208->first);
- xfer += oprot->writeString(_iter208->second);
+ xfer += oprot->writeString(_iter209->first);
+ xfer += oprot->writeString(_iter209->second);
}
xfer += oprot->writeMapEnd();
}
@@ -4813,22 +4969,7 @@ void swap(StorageDescriptor &a, StorageDescriptor &b) {
swap(a.__isset, b.__isset);
}
-StorageDescriptor::StorageDescriptor(const StorageDescriptor& other209) {
- cols = other209.cols;
- location = other209.location;
- inputFormat = other209.inputFormat;
- outputFormat = other209.outputFormat;
- compressed = other209.compressed;
- numBuckets = other209.numBuckets;
- serdeInfo = other209.serdeInfo;
- bucketCols = other209.bucketCols;
- sortCols = other209.sortCols;
- parameters = other209.parameters;
- skewedInfo = other209.skewedInfo;
- storedAsSubDirectories = other209.storedAsSubDirectories;
- __isset = other209.__isset;
-}
-StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other210) {
+StorageDescriptor::StorageDescriptor(const StorageDescriptor& other210) {
cols = other210.cols;
location = other210.location;
inputFormat = other210.inputFormat;
@@ -4842,6 +4983,21 @@ StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other21
skewedInfo = other210.skewedInfo;
storedAsSubDirectories = other210.storedAsSubDirectories;
__isset = other210.__isset;
+}
+StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other211) {
+ cols = other211.cols;
+ location = other211.location;
+ inputFormat = other211.inputFormat;
+ outputFormat = other211.outputFormat;
+ compressed = other211.compressed;
+ numBuckets = other211.numBuckets;
+ serdeInfo = other211.serdeInfo;
+ bucketCols = other211.bucketCols;
+ sortCols = other211.sortCols;
+ parameters = other211.parameters;
+ skewedInfo = other211.skewedInfo;
+ storedAsSubDirectories = other211.storedAsSubDirectories;
+ __isset = other211.__isset;
return *this;
}
void StorageDescriptor::printTo(std::ostream& out) const {
@@ -5011,14 +5167,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionKeys.clear();
- uint32_t _size211;
- ::apache::thrift::protocol::TType _etype214;
- xfer += iprot->readListBegin(_etype214, _size211);
- this->partitionKeys.resize(_size211);
- uint32_t _i215;
- for (_i215 = 0; _i215 < _size211; ++_i215)
+ uint32_t _size212;
+ ::apache::thrift::protocol::TType _etype215;
+ xfer += iprot->readListBegin(_etype215, _size212);
+ this->partitionKeys.resize(_size212);
+ uint32_t _i216;
+ for (_i216 = 0; _i216 < _size212; ++_i216)
{
- xfer += this->partitionKeys[_i215].read(iprot);
+ xfer += this->partitionKeys[_i216].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5031,17 +5187,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size216;
- ::apache::thrift::protocol::TType _ktype217;
- ::apache::thrift::protocol::TType _vtype218;
- xfer += iprot->readMapBegin(_ktype217, _vtype218, _size216);
- uint32_t _i220;
- for (_i220 = 0; _i220 < _size216; ++_i220)
+ uint32_t _size217;
+ ::apache::thrift::protocol::TType _ktype218;
+ ::apache::thrift::protocol::TType _vtype219;
+ xfer += iprot->readMapBegin(_ktype218, _vtype219, _size217);
+ uint32_t _i221;
+ for (_i221 = 0; _i221 < _size217; ++_i221)
{
- std::string _key221;
- xfer += iprot->readString(_key221);
- std::string& _val222 = this->parameters[_key221];
- xfer += iprot->readString(_val222);
+ std::string _key222;
+ xfer += iprot->readString(_key222);
+ std::string& _val223 = this->parameters[_key222];
+ xfer += iprot->readString(_val223);
}
xfer += iprot->readMapEnd();
}
@@ -5146,10 +5302,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionKeys.size()));
- std::vector<FieldSchema> ::const_iterator _iter223;
- for (_iter223 = this->partitionKeys.begin(); _iter223 != this->partitionKeys.end(); ++_iter223)
+ std::vector<FieldSchema> ::const_iterator _iter224;
+ for (_iter224 = this->partitionKeys.begin(); _iter224 != this->partitionKeys.end(); ++_iter224)
{
- xfer += (*_iter223).write(oprot);
+ xfer += (*_iter224).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5158,11 +5314,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter224;
- for (_iter224 = this->parameters.begin(); _iter224 != this->parameters.end(); ++_iter224)
+ std::map<std::string, std::string> ::const_iterator _iter225;
+ for (_iter225 = this->parameters.begin(); _iter225 != this->parameters.end(); ++_iter225)
{
- xfer += oprot->writeString(_iter224->first);
- xfer += oprot->writeString(_iter224->second);
+ xfer += oprot->writeString(_iter225->first);
+ xfer += oprot->writeString(_iter225->second);
}
xfer += oprot->writeMapEnd();
}
@@ -5220,25 +5376,7 @@ void swap(Table &a, Table &b) {
swap(a.__isset, b.__isset);
}
-Table::Table(const Table& other225) {
- tableName = other225.tableName;
- dbName = other225.dbName;
- owner = other225.owner;
- createTime = other225.createTime;
- lastAccessTime = other225.lastAccessTime;
- retention = other225.retention;
- sd = other225.sd;
- partitionKeys = other225.partitionKeys;
- parameters = other225.parameters;
- viewOriginalText = other225.viewOriginalText;
- viewExpandedText = other225.viewExpandedText;
- tableType = other225.tableType;
- privileges = other225.privileges;
- temporary = other225.temporary;
- rewriteEnabled = other225.rewriteEnabled;
- __isset = other225.__isset;
-}
-Table& Table::operator=(const Table& other226) {
+Table::Table(const Table& other226) {
tableName = other226.tableName;
dbName = other226.dbName;
owner = other226.owner;
@@ -5255,6 +5393,24 @@ Table& Table::operator=(const Table& other226) {
temporary = other226.temporary;
rewriteEnabled = other226.rewriteEnabled;
__isset = other226.__isset;
+}
+Table& Table::operator=(const Table& other227) {
+ tableName = other227.tableName;
+ dbName = other227.dbName;
+ owner = other227.owner;
+ createTime = other227.createTime;
+ lastAccessTime = other227.lastAccessTime;
+ retention = other227.retention;
+ sd = other227.sd;
+ partitionKeys = other227.partitionKeys;
+ parameters = other227.parameters;
+ viewOriginalText = other227.viewOriginalText;
+ viewExpandedText = other227.viewExpandedText;
+ tableType = other227.tableType;
+ privileges = other227.privileges;
+ temporary = other227.temporary;
+ rewriteEnabled = other227.rewriteEnabled;
+ __isset = other227.__isset;
return *this;
}
void Table::printTo(std::ostream& out) const {
@@ -5341,14 +5497,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size227;
- ::apache::thrift::protocol::TType _etype230;
- xfer += iprot->readListBegin(_etype230, _size227);
- this->values.resize(_size227);
- uint32_t _i231;
- for (_i231 = 0; _i231 < _size227; ++_i231)
+ uint32_t _size228;
+ ::apache::thrift::protocol::TType _etype231;
+ xfer += iprot->readListBegin(_etype231, _size228);
+ this->values.resize(_size228);
+ uint32_t _i232;
+ for (_i232 = 0; _i232 < _size228; ++_i232)
{
- xfer += iprot->readString(this->values[_i231]);
+ xfer += iprot->readString(this->values[_i232]);
}
xfer += iprot->readListEnd();
}
@@ -5401,17 +5557,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size232;
- ::apache::thrift::protocol::TType _ktype233;
- ::apache::thrift::protocol::TType _vtype234;
- xfer += iprot->readMapBegin(_ktype233, _vtype234, _size232);
- uint32_t _i236;
- for (_i236 = 0; _i236 < _size232; ++_i236)
+ uint32_t _size233;
+ ::apache::thrift::protocol::TType _ktype234;
+ ::apache::thrift::protocol::TType _vtype235;
+ xfer += iprot->readMapBegin(_ktype234, _vtype235, _size233);
+ uint32_t _i237;
+ for (_i237 = 0; _i237 < _size233; ++_i237)
{
- std::string _key237;
- xfer += iprot->readString(_key237);
- std::string& _val238 = this->parameters[_key237];
- xfer += iprot->readString(_val238);
+ std::string _key238;
+ xfer += iprot->readString(_key238);
+ std::string& _val239 = this->parameters[_key238];
+ xfer += iprot->readString(_val239);
}
xfer += iprot->readMapEnd();
}
@@ -5448,10 +5604,10 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
- std::vector<std::string> ::const_iterator _iter239;
- for (_iter239 = this->values.begin(); _iter239 != this->values.end(); ++_iter239)
+ std::vector<std::string> ::const_iterator _iter240;
+ for (_iter240 = this->values.begin(); _iter240 != this->values.end(); ++_iter240)
{
- xfer += oprot->writeString((*_iter239));
+ xfer += oprot->writeString((*_iter240));
}
xfer += oprot->writeListEnd();
}
@@ -5480,11 +5636,11 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter240;
- for (_iter240 = this->parameters.begin(); _iter240 != this->parameters.end(); ++_iter240)
+ std::map<std::string, std::string> ::const_iterator _iter241;
+ for (_iter241 = this->parameters.begin(); _iter241 != this->parameters.end(); ++_iter241)
{
- xfer += oprot->writeString(_iter240->first);
- xfer += oprot->writeString(_iter240->second);
+ xfer += oprot->writeString(_iter241->first);
+ xfer += oprot->writeString(_iter241->second);
}
xfer += oprot->writeMapEnd();
}
@@ -5513,18 +5669,7 @@ void swap(Partition &a, Partition &b) {
swap(a.__isset, b.__isset);
}
-Partition::Partition(const Partition& other241) {
- values = other241.values;
- dbName = other241.dbName;
- tableName = other241.tableName;
- createTime = other241.createTime;
- lastAccessTime = other241.lastAccessTime;
- sd = other241.sd;
- parameters = other241.parameters;
- privileges = other241.privileges;
- __isset = other241.__isset;
-}
-Partition& Partition::operator=(const Partition& other242) {
+Partition::Partition(const Partition& other242) {
values = other242.values;
dbName = other242.dbName;
tableName = other242.tableName;
@@ -5534,6 +5679,17 @@ Partition& Partition::operator=(const Partition& other242) {
parameters = other242.parameters;
privileges = other242.privileges;
__isset = other242.__isset;
+}
+Partition& Partition::operator=(const Partition& other243) {
+ values = other243.values;
+ dbName = other243.dbName;
+ tableName = other243.tableName;
+ createTime = other243.createTime;
+ lastAccessTime = other243.lastAccessTime;
+ sd = other243.sd;
+ parameters = other243.parameters;
+ privileges = other243.privileges;
+ __isset = other243.__isset;
return *this;
}
void Partition::printTo(std::ostream& out) const {
@@ -5605,14 +5761,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size243;
- ::apache::thrift::protocol::TType _etype246;
- xfer += iprot->readListBegin(_etype246, _size243);
- this->values.resize(_size243);
- uint32_t _i247;
- for (_i247 = 0; _i247 < _size243; ++_i247)
+ uint32_t _size244;
+ ::apache::thrift::protocol::TType _etype247;
+ xfer += iprot->readListBegin(_etype247, _size244);
+ this->values.resize(_size244);
+ uint32_t _i248;
+ for (_i248 = 0; _i248 < _size244; ++_i248)
{
- xfer += iprot->readString(this->values[_i247]);
+ xfer += iprot->readString(this->values[_i248]);
}
xfer += iprot->readListEnd();
}
@@ -5649,17 +5805,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size248;
- ::apache::thrift::protocol::TType _ktype249;
- ::apache::thrift::protocol::TType _vtype250;
- xfer += iprot->readMapBegin(_ktype249, _vtype250, _size248);
- uint32_t _i252;
- for (_i252 = 0; _i252 < _size248; ++_i252)
+ uint32_t _size249;
+ ::apache::thrift::protocol::TType _ktype250;
+ ::apache::thrift::protocol::TType _vtype251;
+ xfer += iprot->readMapBegin(_ktype250, _vtype251, _size249);
+ uint32_t _i253;
+ for (_i253 = 0; _i253 < _size249; ++_i253)
{
- std::string _key253;
- xfer += iprot->readString(_key253);
- std::string& _val254 = this->parameters[_key253];
- xfer += iprot->readString(_val254);
+ std::string _key254;
+ xfer += iprot->readString(_key254);
+ std::string& _val255 = this->parameters[_key254];
+ xfer += iprot->readString(_val255);
}
xfer += iprot->readMapEnd();
}
@@ -5696,10 +5852,10 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
- std::vector<std::string> ::const_iterator _iter255;
- for (_iter255 = this->values.begin(); _iter255 != this->values.end(); ++_iter255)
+ std::vector<std::string> ::const_iterator _iter256;
+ for (_iter256 = this->values.begin(); _iter256 != this->values.end(); ++_iter256)
{
- xfer += oprot->writeString((*_iter255));
+ xfer += oprot->writeString((*_iter256));
}
xfer += oprot->writeListEnd();
}
@@ -5720,11 +5876,11 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter256;
- for (_iter256 = this->parameters.begin(); _iter256 != this->parameters.end(); ++_iter256)
+ std::map<std::string, std::string> ::const_iterator _iter257;
+ for (_iter257 = this->parameters.begin(); _iter257 != this->parameters.end(); ++_iter257)
{
- xfer += oprot->writeString(_iter256->first);
- xfer += oprot->writeString(_iter256->second);
+ xfer += oprot->writeString(_iter257->first);
+ xfer += oprot->writeString(_iter257->second);
}
xfer += oprot->writeMapEnd();
}
@@ -5751,16 +5907,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) {
swap(a.__isset, b.__isset);
}
-PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other257) {
- values = other257.values;
- createTime = other257.createTime;
- lastAccessTime = other257.lastAccessTime;
- relativePath = other257.relativePath;
- parameters = other257.parameters;
- privileges = other257.privileges;
- __isset = other257.__isset;
-}
-PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other258) {
+PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other258) {
values = other258.values;
createTime = other258.createTime;
lastAccessTime = other258.lastAccessTime;
@@ -5768,6 +5915,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe
parameters = other258.parameters;
privileges = other258.privileges;
__isset = other258.__isset;
+}
+PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other259) {
+ values = other259.values;
+ createTime = other259.createTime;
+ lastAccessTime = other259.lastAccessTime;
+ relativePath = other259.relativePath;
+ parameters = other259.parameters;
+ privileges = other259.privileges;
+ __isset = other259.__isset;
return *this;
}
void PartitionWithoutSD::printTo(std::ostream& out) const {
@@ -5820,14 +5976,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size259;
- ::apache::thrift::protocol::TType _etype262;
- xfer += iprot->readListBegin(_etype262, _size259);
- this->partitions.resize(_size259);
- uint32_t _i263;
- for (_i263 = 0; _i263 < _size259; ++_i263)
+ uint32_t _size260;
+ ::apache::thrift::protocol::TType _etype263;
+ xfer += iprot->readListBegin(_etype263, _size260);
+ this->partitions.resize(_size260);
+ uint32_t _i264;
+ for (_i264 = 0; _i264 < _size260; ++_i264)
{
- xfer += this->partitions[_i263].read(iprot);
+ xfer += this->partitions[_i264].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5864,10 +6020,10 @@ uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<PartitionWithoutSD> ::const_iterator _iter264;
- for (_iter264 = this->partitions.begin(); _iter264 != this->partitions.end(); ++_iter264)
+ std::vector<PartitionWithoutSD> ::const_iterator _iter265;
+ for (_iter265 = this->partitions.begin(); _iter265 != this->partitions.end(); ++_iter265)
{
- xfer += (*_iter264).write(oprot);
+ xfer += (*_iter265).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5889,15 +6045,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) {
swap(a.__isset, b.__isset);
}
-PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other265) {
- partitions = other265.partitions;
- sd = other265.sd;
- __isset = other265.__isset;
-}
-PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other266) {
+PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other266) {
partitions = other266.partitions;
sd = other266.sd;
__isset = other266.__isset;
+}
+PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other267) {
+ partitions = other267.partitions;
+ sd = other267.sd;
+ __isset = other267.__isset;
return *this;
}
void PartitionSpecWithSharedSD::printTo(std::ostream& out) const {
@@ -5942,14 +6098,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size267;
- ::apache::thrift::protocol::TType _etype270;
- xfer += iprot->readListBegin(_etype270, _size267);
- this->partitions.resize(_size267);
- uint32_t _i271;
- for (_i271 = 0; _i271 < _size267; ++_i271)
+ uint32_t _size268;
+ ::apache::thrift::protocol::TType _etype271;
+ xfer += iprot->readListBegin(_etype271, _size268);
+ this->partitions.resize(_size268);
+ uint32_t _i272;
+ for (_i272 = 0; _i272 < _size268; ++_i272)
{
- xfer += this->partitions[_i271].read(iprot);
+ xfer += this->partitions[_i272].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -5978,10 +6134,10 @@ uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter272;
- for (_iter272 = this->partitions.begin(); _iter272 != this->partitions.end(); ++_iter272)
+ std::vector<Partition> ::const_iterator _iter273;
+ for (_iter273 = this->partitions.begin(); _iter273 != this->partitions.end(); ++_iter273)
{
- xfer += (*_iter272).write(oprot);
+ xfer += (*_iter273).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5998,13 +6154,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) {
swap(a.__isset, b.__isset);
}
-PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other273) {
- partitions = other273.partitions;
- __isset = other273.__isset;
-}
-PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other274) {
+PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other274) {
partitions = other274.partitions;
__isset = other274.__isset;
+}
+PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other275) {
+ partitions = other275.partitions;
+ __isset = other275.__isset;
return *this;
}
void PartitionListComposingSpec::printTo(std::ostream& out) const {
@@ -6156,21 +6312,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) {
swap(a.__isset, b.__isset);
}
-PartitionSpec::PartitionSpec(const PartitionSpec& other275) {
- dbName = other275.dbName;
- tableName = other275.tableName;
- rootPath = other275.rootPath;
- sharedSDPartitionSpec = other275.sharedSDPartitionSpec;
- partitionList = other275.partitionList;
- __isset = other275.__isset;
-}
-PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other276) {
+PartitionSpec::PartitionSpec(const PartitionSpec& other276) {
dbName = other276.dbName;
tableName = other276.tableName;
rootPath = other276.rootPath;
sharedSDPartitionSpec = other276.sharedSDPartitionSpec;
partitionList = other276.partitionList;
__isset = other276.__isset;
+}
+PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other277) {
+ dbName = other277.dbName;
+ tableName = other277.tableName;
+ rootPath = other277.rootPath;
+ sharedSDPartitionSpec = other277.sharedSDPartitionSpec;
+ partitionList = other277.partitionList;
+ __isset = other277.__isset;
return *this;
}
void PartitionSpec::printTo(std::ostream& out) const {
@@ -6318,17 +6474,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size277;
- ::apache::thrift::protocol::TType _ktype278;
- ::apache::thrift::protocol::TType _vtype279;
- xfer += iprot->readMapBegin(_ktype278, _vtype279, _size277);
- uint32_t _i281;
- for (_i281 = 0; _i281 < _size277; ++_i281)
+ uint32_t _size278;
+ ::apache::thrift::protocol::TType _ktype279;
+ ::apache::thrift::protocol::TType _vtype280;
+ xfer += iprot->readMapBegin(_ktype279, _vtype280, _size278);
+ uint32_t _i282;
+ for (_i282 = 0; _i282 < _size278; ++_i282)
{
- std::string _key282;
- xfer += iprot->readString(_key282);
- std::string& _val283 = this->parameters[_key282];
- xfer += iprot->readString(_val283);
+ std::string _key283;
+ xfer += iprot->readString(_key283);
+ std::string& _val284 = this->parameters[_key283];
+ xfer += iprot->readString(_val284);
}
xfer += iprot->readMapEnd();
}
@@ -6397,11 +6553,11 @@ uint32_t Index::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter284;
- for (_iter284 = this->parameters.begin(); _iter284 != this->parameters.end(); ++_iter284)
+ std::map<std::string, std::string> ::const_iterator _iter285;
+ for (_iter285 = this->parameters.begin(); _iter285 != this->parameters.end(); ++_iter285)
{
- xfer += oprot->writeString(_iter284->first);
- xfer += oprot->writeString(_iter284->second);
+ xfer += oprot->writeString(_iter285->first);
+ xfer += oprot->writeString(_iter285->second);
}
xfer += oprot->writeMapEnd();
}
@@ -6431,20 +6587,7 @@ void swap(Index &a, Index &b) {
swap(a.__isset, b.__isset);
}
-Index::Index(const Index& other285) {
- indexName = other285.indexName;
- indexHandlerClass = other285.indexHandlerClass;
- dbName = other285.dbName;
- origTableName = other285.origTableName;
- createTime = other285.createTime;
- lastAccessTime = other285.lastAccessTime;
- indexTableName = other285.indexTableName;
- sd = other285.sd;
- parameters = other285.parameters;
- deferredRebuild = other285.deferredRebuild;
- __isset = other285.__isset;
-}
-Index& Index::operator=(const Index& other286) {
+Index::Index(const Index& other286) {
indexName = other286.indexName;
indexHandlerClass = other286.indexHandlerClass;
dbName = other286.dbName;
@@ -6456,6 +6599,19 @@ Index& Index::operator=(const Index& other286) {
parameters = other286.parameters;
deferredRebuild = other286.deferredRebuild;
__isset = other286.__isset;
+}
+Index& Index::operator=(const Index& other287) {
+ indexName = other287.indexName;
+ indexHandlerClass = other287.indexHandlerClass;
+ dbName = other287.dbName;
+ origTableName = other287.origTableName;
+ createTime = other287.createTime;
+ lastAccessTime = other287.lastAccessTime;
+ indexTableName = other287.indexTableName;
+ sd = other287.sd;
+ parameters = other287.parameters;
+ deferredRebuild = other287.deferredRebuild;
+ __isset = other287.__isset;
return *this;
}
void Index::printTo(std::ostream& out) const {
@@ -6606,19 +6762,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other287) {
- numTrues = other287.numTrues;
- numFalses = other287.numFalses;
- numNulls = other287.numNulls;
- bitVectors = other287.bitVectors;
- __isset = other287.__isset;
-}
-BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other288) {
+BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other288) {
numTrues = other288.numTrues;
numFalses = other288.numFalses;
numNulls = other288.numNulls;
bitVectors = other288.bitVectors;
__isset = other288.__isset;
+}
+BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other289) {
+ numTrues = other289.numTrues;
+ numFalses = other289.numFalses;
+ numNulls = other289.numNulls;
+ bitVectors = other289.bitVectors;
+ __isset = other289.__isset;
return *this;
}
void BooleanColumnStatsData::printTo(std::ostream& out) const {
@@ -6781,21 +6937,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other289) {
- lowValue = other289.lowValue;
- highValue = other289.highValue;
- numNulls = other289.numNulls;
- numDVs = other289.numDVs;
- bitVectors = other289.bitVectors;
- __isset = other289.__isset;
-}
-DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other290) {
+DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other290) {
lowValue = other290.lowValue;
highValue = other290.highValue;
numNulls = other290.numNulls;
numDVs = other290.numDVs;
bitVectors = other290.bitVectors;
__isset = other290.__isset;
+}
+DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other291) {
+ lowValue = other291.lowValue;
+ highValue = other291.highValue;
+ numNulls = other291.numNulls;
+ numDVs = other291.numDVs;
+ bitVectors = other291.bitVectors;
+ __isset = other291.__isset;
return *this;
}
void DoubleColumnStatsData::printTo(std::ostream& out) const {
@@ -6959,21 +7115,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other291) {
- lowValue = other291.lowValue;
- highValue = other291.highValue;
- numNulls = other291.numNulls;
- numDVs = other291.numDVs;
- bitVectors = other291.bitVectors;
- __isset = other291.__isset;
-}
-LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other292) {
+LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other292) {
lowValue = other292.lowValue;
highValue = other292.highValue;
numNulls = other292.numNulls;
numDVs = other292.numDVs;
bitVectors = other292.bitVectors;
__isset = other292.__isset;
+}
+LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other293) {
+ lowValue = other293.lowValue;
+ highValue = other293.highValue;
+ numNulls = other293.numNulls;
+ numDVs = other293.numDVs;
+ bitVectors = other293.bitVectors;
+ __isset = other293.__isset;
return *this;
}
void LongColumnStatsData::printTo(std::ostream& out) const {
@@ -7139,21 +7295,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other293) {
- maxColLen = other293.maxColLen;
- avgColLen = other293.avgColLen;
- numNulls = other293.numNulls;
- numDVs = other293.numDVs;
- bitVectors = other293.bitVectors;
- __isset = other293.__isset;
-}
-StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other294) {
+StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other294) {
maxColLen = other294.maxColLen;
avgColLen = other294.avgColLen;
numNulls = other294.numNulls;
numDVs = other294.numDVs;
bitVectors = other294.bitVectors;
__isset = other294.__isset;
+}
+StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other295) {
+ maxColLen = other295.maxColLen;
+ avgColLen = other295.avgColLen;
+ numNulls = other295.numNulls;
+ numDVs = other295.numDVs;
+ bitVectors = other295.bitVectors;
+ __isset = other295.__isset;
return *this;
}
void StringColumnStatsData::printTo(std::ostream& out) const {
@@ -7299,19 +7455,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other295) {
- maxColLen = other295.maxColLen;
- avgColLen = other295.avgColLen;
- numNulls = other295.numNulls;
- bitVectors = other295.bitVectors;
- __isset = other295.__isset;
-}
-BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other296) {
+BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other296) {
maxColLen = other296.maxColLen;
avgColLen = other296.avgColLen;
numNulls = other296.numNulls;
bitVectors = other296.bitVectors;
__isset = other296.__isset;
+}
+BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other297) {
+ maxColLen = other297.maxColLen;
+ avgColLen = other297.avgColLen;
+ numNulls = other297.numNulls;
+ bitVectors = other297.bitVectors;
+ __isset = other297.__isset;
return *this;
}
void BinaryColumnStatsData::printTo(std::ostream& out) const {
@@ -7416,13 +7572,13 @@ void swap(Decimal &a, Decimal &b) {
swap(a.scale, b.scale);
}
-Decimal::Decimal(const Decimal& other297) {
- unscaled = other297.unscaled;
- scale = other297.scale;
-}
-Decimal& Decimal::operator=(const Decimal& other298) {
+Decimal::Decimal(const Decimal& other298) {
unscaled = other298.unscaled;
scale = other298.scale;
+}
+Decimal& Decimal::operator=(const Decimal& other299) {
+ unscaled = other299.unscaled;
+ scale = other299.scale;
return *this;
}
void Decimal::printTo(std::ostream& out) const {
@@ -7583,21 +7739,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other299) {
- lowValue = other299.lowValue;
- highValue = other299.highValue;
- numNulls = other299.numNulls;
- numDVs = other299.numDVs;
- bitVectors = other299.bitVectors;
- __isset = other299.__isset;
-}
-DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other300) {
+DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other300) {
lowValue = other300.lowValue;
highValue = other300.highValue;
numNulls = other300.numNulls;
numDVs = other300.numDVs;
bitVectors = other300.bitVectors;
__isset = other300.__isset;
+}
+DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other301) {
+ lowValue = other301.lowValue;
+ highValue = other301.highValue;
+ numNulls = other301.numNulls;
+ numDVs = other301.numDVs;
+ bitVectors = other301.bitVectors;
+ __isset = other301.__isset;
return *this;
}
void DecimalColumnStatsData::printTo(std::ostream& out) const {
@@ -7683,11 +7839,11 @@ void swap(Date &a, Date &b) {
swap(a.daysSinceEpoch, b.daysSinceEpoch);
}
-Date::Date(const Date& other301) {
- daysSinceEpoch = other301.daysSinceEpoch;
-}
-Date& Date::operator=(const Date& other302) {
+Date::Date(const Date& other302) {
daysSinceEpoch = other302.daysSinceEpoch;
+}
+Date& Date::operator=(const Date& other303) {
+ daysSinceEpoch = other303.daysSinceEpoch;
return *this;
}
void Date::printTo(std::ostream& out) const {
@@ -7847,21 +8003,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other303) {
- lowValue = other303.lowValue;
- highValue = other303.highValue;
- numNulls = other303.numNulls;
- numDVs = other303.numDVs;
- bitVectors = other303.bitVectors;
- __isset = other303.__isset;
-}
-DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other304) {
+DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other304) {
lowValue = other304.lowValue;
highValue = other304.highValue;
numNulls = other304.numNulls;
numDVs = other304.numDVs;
bitVectors = other304.bitVectors;
__isset = other304.__isset;
+}
+DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other305) {
+ lowValue = other305.lowValue;
+ highValue = other305.highValue;
+ numNulls = other305.numNulls;
+ numDVs = other305.numDVs;
+ bitVectors = other305.bitVectors;
+ __isset = other305.__isset;
return *this;
}
void DateColumnStatsData::printTo(std::ostream& out) const {
@@ -8047,17 +8203,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) {
swap(a.__isset, b.__isset);
}
-ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other305) {
- booleanStats = other305.booleanStats;
- longStats = other305.longStats;
- doubleStats = other305.doubleStats;
- stringStats = other305.stringStats;
- binaryStats = other305.binaryStats;
- decimalStats = other305.decimalStats;
- dateStats = other305.dateStats;
- __isset = other305.__isset;
-}
-ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other306) {
+ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other306) {
booleanStats = other306.booleanStats;
longStats = other306.longStats;
doubleStats = other306.doubleStats;
@@ -8066,6 +8212,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData
decimalStats = other306.decimalStats;
dateStats = other306.dateStats;
__isset = other306.__isset;
+}
+ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other307) {
+ booleanStats = other307.booleanStats;
+ longStats = other307.longStats;
+ doubleStats = other307.doubleStats;
+ stringStats = other307.stringStats;
+ binaryStats = other307.binaryStats;
+ decimalStats = other307.decimalStats;
+ dateStats = other307.dateStats;
+ __isset = other307.__isset;
return *this;
}
void ColumnStatisticsData::printTo(std::ostream& out) const {
@@ -8193,15 +8349,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) {
swap(a.statsData, b.statsData);
}
-ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other307) {
- colName = other307.colName;
- colType = other307.colType;
- statsData = other307.statsData;
-}
-ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other308) {
+ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other308) {
colName = other308.colName;
colType = other308.colType;
statsData = other308.statsData;
+}
+ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other309) {
+ colName = other309.colName;
+ colType = other309.colType;
+ statsData = other309.statsData;
return *this;
}
void ColumnStatisticsObj::printTo(std::ostream& out) const {
@@ -8364,21 +8520,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) {
swap(a.__isset, b.__isset);
}
-ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other309) {
- isTblLevel = other309.isTblLevel;
- dbName = other309.dbName;
- tableName = other309.tableName;
- partName = other309.partName;
- lastAnalyzed = other309.lastAnalyzed;
- __isset = other309.__isset;
-}
-ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other310) {
+ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other310) {
isTblLevel = other310.isTblLevel;
dbName = other310.dbName;
tableName = other310.tableName;
partName = other310.partName;
lastAnalyzed = other310.lastAnalyzed;
__isset = other310.__isset;
+}
+ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other311) {
+ isTblLevel = other311.isTblLevel;
+ dbName = other311.dbName;
+ tableName = other311.tableName;
+ partName = other311.partName;
+ lastAnalyzed = other311.lastAnalyzed;
+ __isset = other311.__isset;
return *this;
}
void ColumnStatisticsDesc::printTo(std::ostream& out) const {
@@ -8440,14 +8596,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->statsObj.clear();
- uint32_t _size311;
- ::apache::thrift::protocol::TType _etype314;
- xfer += iprot->readListBegin(_etype314, _size311);
- this->statsObj.resize(_size311);
- uint32_t _i315;
- for (_i315 = 0; _i315 < _size311; ++_i315)
+ uint32_t _size312;
+ ::apache::thrift::protocol::TType _etype315;
+ xfer += iprot->readListBegin(_etype315, _size312);
+ this->statsObj.resize(_size312);
+ uint32_t _i316;
+ for (_i316 = 0; _i316 < _size312; ++_i316)
{
- xfer += this->statsObj[_i315].read(iprot);
+ xfer += this->statsObj[_i316].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8484,10 +8640,10 @@ uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->statsObj.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter316;
- for (_iter316 = this->statsObj.begin(); _iter316 != this->statsObj.end(); ++_iter316)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter317;
+ for (_iter317 = this->statsObj.begin(); _iter317 != this->statsObj.end(); ++_iter317)
{
- xfer += (*_iter316).write(oprot);
+ xfer += (*_iter317).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8504,13 +8660,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) {
swap(a.statsObj, b.statsObj);
}
-ColumnStatistics::ColumnStatistics(const ColumnStatistics& other317) {
- statsDesc = other317.statsDesc;
- statsObj = other317.statsObj;
-}
-ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other318) {
+ColumnStatistics::ColumnStatistics(const ColumnStatistics& other318) {
statsDesc = other318.statsDesc;
statsObj = other318.statsObj;
+}
+ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other319) {
+ statsDesc = other319.statsDesc;
+ statsObj = other319.statsObj;
return *this;
}
void ColumnStatistics::printTo(std::ostream& out) const {
@@ -8561,14 +8717,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size319;
- ::apache::thrift::protocol::TType _etype322;
- xfer += iprot->readListBegin(_etype322, _size319);
- this->colStats.resize(_size319);
- uint32_t _i323;
- for (_i323 = 0; _i323 < _size319; ++_i323)
+ uint32_t _size320;
+ ::apache::thrift::protocol::TType _etype323;
+ xfer += iprot->readListBegin(_etype323, _size320);
+ this->colStats.resize(_size320);
+ uint32_t _i324;
+ for (_i324 = 0; _i324 < _size320; ++_i324)
{
- xfer += this->colStats[_i323].read(iprot);
+ xfer += this->colStats[_i324].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8609,10 +8765,10 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter324;
- for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); ++_iter324)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter325;
+ for (_iter325 = this->colStats.begin(); _iter325 != this->colStats.end(); ++_iter325)
{
- xfer += (*_iter324).write(oprot);
+ xfer += (*_iter325).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8633,13 +8789,13 @@ void swap(AggrStats &a, AggrStats &b) {
swap(a.partsFound, b.partsFound);
}
-AggrStats::AggrStats(const AggrStats& other325) {
- colStats = other325.colStats;
- partsFound = other325.partsFound;
-}
-AggrStats& AggrStats::operator=(const AggrStats& other326) {
+AggrStats::AggrStats(const AggrStats& other326) {
colStats = other326.colStats;
partsFound = other326.partsFound;
+}
+AggrStats& AggrStats::operator=(const AggrStats& other327) {
+ colStats = other327.colStats;
+ partsFound = other327.partsFound;
return *this;
}
void AggrStats::printTo(std::ostream& out) const {
@@ -8690,14 +8846,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size327;
- ::apache::thrift::protocol::TType _etype330;
- xfer += iprot->readListBegin(_etype330, _size327);
- this->colStats.resize(_size327);
- uint32_t _i331;
- for (_i331 = 0; _i331 < _size327; ++_i331)
+ uint32_t _size328;
+ ::apache::thrift::protocol::TType _etype331;
+ xfer += iprot->readListBegin(_etype331, _size328);
+ this->colStats.resize(_size328);
+ uint32_t _i332;
+ for (_i332 = 0; _i332 < _size328; ++_i332)
{
- xfer += this->colStats[_i331].read(iprot);
+ xfer += this->colStats[_i332].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8736,10 +8892,10 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatistics> ::const_iterator _iter332;
- for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); ++_iter332)
+ std::vector<ColumnStatistics> ::const_iterator _iter333;
+ for (_iter333 = this->colStats.begin(); _iter333 != this->colStats.end(); ++_iter333)
{
- xfer += (*_iter332).write(oprot);
+ xfer += (*_iter333).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8762,15 +8918,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) {
swap(a.__isset, b.__isset);
}
-SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other333) {
- colStats = other333.colStats;
- needMerge = other333.needMerge;
- __isset = other333.__isset;
-}
-SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other334) {
+SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other334) {
colStats = other334.colStats;
needMerge = other334.needMerge;
__isset = other334.__isset;
+}
+SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other335) {
+ colStats = other335.colStats;
+ needMerge = other335.needMerge;
+ __isset = other335.__isset;
return *this;
}
void SetPartitionsStatsRequest::printTo(std::ostream& out) const {
@@ -8819,14 +8975,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fieldSchemas.clear();
- uint32_t _size335;
- ::apache::thrift::protocol::TType _etype338;
- xfer += iprot->readListBegin(_etype338, _size335);
- this->fieldSchemas.resize(_size335);
- uint32_t _i339;
- for (_i339 = 0; _i339 < _size335; ++_i339)
+ uint32_t _size336;
+ ::apache::thrift::protocol::TType _etype339;
+ xfer += iprot->readListBegin(_etype339, _size336);
+ this->fieldSchemas.resize(_size336);
+ uint32_t _i340;
+ for (_i340 = 0; _i340 < _size336; ++_i340)
{
- xfer += this->fieldSchemas[_i339].read(iprot);
+ xfer += this->fieldSchemas[_i340].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8839,17 +8995,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size340;
- ::apache::thrift::protocol::TType _ktype341;
- ::apache::thrift::protocol::TType _vtype342;
- xfer += iprot->readMapBegin(_ktype341, _vtype342, _size340);
- uint32_t _i344;
- for (_i344 = 0; _i344 < _size340; ++_i344)
+ uint32_t _size341;
+ ::apache::thrift::protocol::TType _ktype342;
+ ::apache::thrift::protocol::TType _vtype343;
+ xfer += iprot->readMapBegin(_ktype342, _vtype343, _size341);
+ uint32_t _i345;
+ for (_i345 = 0; _i345 < _size341; ++_i345)
{
- std::string _key345;
- xfer += iprot->readString(_key345);
- std::string& _val346 = this->properties[_key345];
- xfer += iprot->readString(_val346);
+ std::string _key346;
+ xfer += iprot->readString(_key346);
+ std::string& _val347 = this->properties[_key346];
+ xfer += iprot->readString(_val347);
}
xfer += iprot->readMapEnd();
}
@@ -8878,10 +9034,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fieldSchemas.size()));
- std::vector<FieldSchema> ::const_iterator _iter347;
- for (_iter347 = this->fieldSchemas.begin(); _iter347 != this->fieldSchemas.end(); ++_iter347)
+ std::vector<FieldSchema> ::const_iterator _iter348;
+ for (_iter348 = this->fieldSchemas.begin(); _iter348 != this->fieldSchemas.end(); ++_iter348)
{
- xfer += (*_iter347).write(oprot);
+ xfer += (*_iter348).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8890,11 +9046,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter348;
- for (_iter348 = this->properties.begin(); _iter348 != this->properties.end(); ++_iter348)
+ std::map<std::string, std::string> ::const_iterator _iter349;
+ for (_iter349 = this->properties.begin(); _iter349 != this->properties.end(); ++_iter349)
{
- xfer += oprot->writeString(_iter348->first);
- xfer += oprot->writeString(_iter348->second);
+ xfer += oprot->writeString(_iter349->first);
+ xfer += oprot->writeString(_iter349->second);
}
xfer += oprot->writeMapEnd();
}
@@ -8912,15 +9068,15 @@ void swap(Schema &a, Schema &b) {
swap(a.__isset, b.__isset);
}
-Schema::Schema(const Schema& other349) {
- fieldSchemas = other349.fieldSchemas;
- properties = other349.properties;
- __isset = other349.__isset;
-}
-Schema& Schema::operator=(const Schema& other350) {
+Schema::Schema(const Schema& other350) {
fieldSchemas = other350.fieldSchemas;
properties = other350.properties;
__isset = other350.__isset;
+}
+Schema& Schema::operator=(const Schema& other351) {
+ fieldSchemas = other351.fieldSchemas;
+ properties = other351.properties;
+ __isset = other351.__isset;
return *this;
}
void Schema::printTo(std::ostream& out) const {
@@ -8965,17 +9121,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size351;
- ::apache::thrift::protocol::TType _ktype352;
- ::apache::thrift::protocol::TType _vtype353;
- xfer += iprot->readMapBegin(_ktype352, _vtype353, _size351);
- uint32_t _i355;
- for (_i355 = 0; _i355 < _size351; ++_i355)
+ uint32_t _size352;
+ ::apache::thrift::protocol::TType _ktype353;
+ ::apache::thrift::protocol::TType _vtype354;
+ xfer += iprot->readMapBegin(_ktype353, _vtype354, _size352);
+ uint32_t _i356;
+ for (_i356 = 0; _i356 < _size352; ++_i356)
{
- std::string _key356;
- xfer += iprot->readString(_key356);
- std::string& _val357 = this->properties[_key356];
- xfer += iprot->readString(_val357);
+ std::string _key357;
+ xfer += iprot->readString(_key357);
+ std::string& _val358 = this->properties[_key357];
+ xfer += iprot->readString(_val358);
}
xfer += iprot->readMapEnd();
}
@@ -9004,11 +9160,11 @@ uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter358;
- for (_iter358 = this->properties.begin(); _iter358 != this->properties.end(); ++_iter358)
+ std::map<std::string, std::string> ::const_iterator _iter359;
+ for (_iter359 = this->properties.begin(); _iter359 != this->properties.end(); ++_iter359)
{
- xfer += oprot->writeString(_iter358->first);
- xfer += oprot->writeString(_iter358->second);
+ xfer += oprot->writeString(_iter359->first);
+ xfer += oprot->writeString(_iter359->second);
}
xfer += oprot->writeMapEnd();
}
@@ -9025,13 +9181,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) {
swap(a.__isset, b.__isset);
}
-EnvironmentContext::EnvironmentContext(const EnvironmentContext& other359) {
- properties = other359.properties;
- __isset = other359.__isset;
-}
-EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other360) {
+EnvironmentContext::EnvironmentContext(const EnvironmentContext& other360) {
properties = other360.properties;
__isset = other360.__isset;
+}
+EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other361) {
+ properties = other361.properties;
+ __isset = other361.__isset;
return *this;
}
void EnvironmentContext::printTo(std::ostream& out) const {
@@ -9133,13 +9289,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other361) {
- db_name = other361.db_name;
- tbl_name = other361.tbl_name;
-}
-PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other362) {
+PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other362) {
db_name = other362.db_name;
tbl_name = other362.tbl_name;
+}
+PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other363) {
+ db_name = other363.db_name;
+ tbl_name = other363.tbl_name;
return *this;
}
void PrimaryKeysRequest::printTo(std::ostream& out) const {
@@ -9185,14 +9341,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->primaryKeys.clear();
- uint32_t _size363;
- ::apache::thrift::protocol::TType _etype366;
- xfer += iprot->readListBegin(_etype366, _size363);
- this->primaryKeys.resize(_size363);
- uint32_t _i367;
- for (_i367 = 0; _i367 < _size363; ++_i367)
+ uint32_t _size364;
+ ::apache::thrift::protocol::TType _etype367;
+ xfer += iprot->readListBegin(_etype367, _size364);
+ this->primaryKeys.resize(_size364);
+ uint32_t _i368;
+ for (_i368 = 0; _i368 < _size364; ++_i368)
{
- xfer += this->primaryKeys[_i367].read(iprot);
+ xfer += this->primaryKeys[_i368].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9223,10 +9379,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter368;
- for (_iter368 = this->primaryKeys.begin(); _iter368 != this->primaryKeys.end(); ++_iter368)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter369;
+ for (_iter369 = this->primaryKeys.begin(); _iter369 != this->primaryKeys.end(); ++_iter369)
{
- xfer += (*_iter368).write(oprot);
+ xfer += (*_iter369).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9242,11 +9398,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) {
swap(a.primaryKeys, b.primaryKeys);
}
-PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other369) {
- primaryKeys = other369.primaryKeys;
-}
-PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other370) {
+PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other370) {
primaryKeys = other370.primaryKeys;
+}
+PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other371) {
+ primaryKeys = other371.primaryKeys;
return *this;
}
void PrimaryKeysResponse::printTo(std::ostream& out) const {
@@ -9377,19 +9533,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) {
swap(a.__isset, b.__isset);
}
-ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other371) {
- parent_db_name = other371.parent_db_name;
- parent_tbl_name = other371.parent_tbl_name;
- foreign_db_name = other371.foreign_db_name;
- foreign_tbl_name = other371.foreign_tbl_name;
- __isset = other371.__isset;
-}
-ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other372) {
+ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other372) {
parent_db_name = other372.parent_db_name;
parent_tbl_name = other372.parent_tbl_name;
foreign_db_name = other372.foreign_db_name;
foreign_tbl_name = other372.foreign_tbl_name;
__isset = other372.__isset;
+}
+ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other373) {
+ parent_db_name = other373.parent_db_name;
+ parent_tbl_name = other373.parent_tbl_name;
+ foreign_db_name = other373.foreign_db_name;
+ foreign_tbl_name = other373.foreign_tbl_name;
+ __isset = other373.__isset;
return *this;
}
void ForeignKeysRequest::printTo(std::ostream& out) const {
@@ -9437,14 +9593,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->foreignKeys.clear();
- uint32_t _size373;
- ::apache::thrift::protocol::TType _etype376;
- xfer += iprot->readListBegin(_etype376, _size373);
- this->foreignKeys.resize(_size373);
- uint32_t _i377;
- for (_i377 = 0; _i377 < _size373; ++_i377)
+ uint32_t _size374;
+ ::apache::thrift::protocol::TType _etype377;
+ xfer += iprot->readListBegin(_etype377, _size374);
+ this->foreignKeys.resize(_size374);
+ uint32_t _i378;
+ for (_i378 = 0; _i378 < _size374; ++_i378)
{
- xfer += this->foreignKeys[_i377].read(iprot);
+ xfer += this->foreignKeys[_i378].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9475,10 +9631,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->for
<TRUNCATED>