You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by mi...@apache.org on 2017/09/19 20:50:05 UTC
[09/12] hive git commit: HIVE-17466: Metastore API to list unique
partition-key-value combinations (Thiruvel Thirumoolan,
reviewed by Mithun Radhakrishnan)
http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/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 5c09fdd..b3c9798 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
@@ -12290,6 +12290,503 @@ void DropPartitionsRequest::printTo(std::ostream& out) const {
}
+PartitionValuesRequest::~PartitionValuesRequest() throw() {
+}
+
+
+void PartitionValuesRequest::__set_dbName(const std::string& val) {
+ this->dbName = val;
+}
+
+void PartitionValuesRequest::__set_tblName(const std::string& val) {
+ this->tblName = val;
+}
+
+void PartitionValuesRequest::__set_partitionKeys(const std::vector<FieldSchema> & val) {
+ this->partitionKeys = val;
+}
+
+void PartitionValuesRequest::__set_applyDistinct(const bool val) {
+ this->applyDistinct = val;
+__isset.applyDistinct = true;
+}
+
+void PartitionValuesRequest::__set_filter(const std::string& val) {
+ this->filter = val;
+__isset.filter = true;
+}
+
+void PartitionValuesRequest::__set_partitionOrder(const std::vector<FieldSchema> & val) {
+ this->partitionOrder = val;
+__isset.partitionOrder = true;
+}
+
+void PartitionValuesRequest::__set_ascending(const bool val) {
+ this->ascending = val;
+__isset.ascending = true;
+}
+
+void PartitionValuesRequest::__set_maxParts(const int64_t val) {
+ this->maxParts = val;
+__isset.maxParts = true;
+}
+
+uint32_t PartitionValuesRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_dbName = false;
+ bool isset_tblName = false;
+ bool isset_partitionKeys = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dbName);
+ isset_dbName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tblName);
+ isset_tblName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->partitionKeys.clear();
+ uint32_t _size533;
+ ::apache::thrift::protocol::TType _etype536;
+ xfer += iprot->readListBegin(_etype536, _size533);
+ this->partitionKeys.resize(_size533);
+ uint32_t _i537;
+ for (_i537 = 0; _i537 < _size533; ++_i537)
+ {
+ xfer += this->partitionKeys[_i537].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_partitionKeys = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->applyDistinct);
+ this->__isset.applyDistinct = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->filter);
+ this->__isset.filter = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->partitionOrder.clear();
+ uint32_t _size538;
+ ::apache::thrift::protocol::TType _etype541;
+ xfer += iprot->readListBegin(_etype541, _size538);
+ this->partitionOrder.resize(_size538);
+ uint32_t _i542;
+ for (_i542 = 0; _i542 < _size538; ++_i542)
+ {
+ xfer += this->partitionOrder[_i542].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.partitionOrder = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->ascending);
+ this->__isset.ascending = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->maxParts);
+ this->__isset.maxParts = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_dbName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_tblName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_partitionKeys)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t PartitionValuesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("PartitionValuesRequest");
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tblName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 3);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionKeys.size()));
+ std::vector<FieldSchema> ::const_iterator _iter543;
+ for (_iter543 = this->partitionKeys.begin(); _iter543 != this->partitionKeys.end(); ++_iter543)
+ {
+ xfer += (*_iter543).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.applyDistinct) {
+ xfer += oprot->writeFieldBegin("applyDistinct", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->applyDistinct);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.filter) {
+ xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->filter);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.partitionOrder) {
+ xfer += oprot->writeFieldBegin("partitionOrder", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionOrder.size()));
+ std::vector<FieldSchema> ::const_iterator _iter544;
+ for (_iter544 = this->partitionOrder.begin(); _iter544 != this->partitionOrder.end(); ++_iter544)
+ {
+ xfer += (*_iter544).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.ascending) {
+ xfer += oprot->writeFieldBegin("ascending", ::apache::thrift::protocol::T_BOOL, 7);
+ xfer += oprot->writeBool(this->ascending);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.maxParts) {
+ xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I64, 8);
+ xfer += oprot->writeI64(this->maxParts);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionValuesRequest &a, PartitionValuesRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
+ swap(a.partitionKeys, b.partitionKeys);
+ swap(a.applyDistinct, b.applyDistinct);
+ swap(a.filter, b.filter);
+ swap(a.partitionOrder, b.partitionOrder);
+ swap(a.ascending, b.ascending);
+ swap(a.maxParts, b.maxParts);
+ swap(a.__isset, b.__isset);
+}
+
+PartitionValuesRequest::PartitionValuesRequest(const PartitionValuesRequest& other545) {
+ dbName = other545.dbName;
+ tblName = other545.tblName;
+ partitionKeys = other545.partitionKeys;
+ applyDistinct = other545.applyDistinct;
+ filter = other545.filter;
+ partitionOrder = other545.partitionOrder;
+ ascending = other545.ascending;
+ maxParts = other545.maxParts;
+ __isset = other545.__isset;
+}
+PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other546) {
+ dbName = other546.dbName;
+ tblName = other546.tblName;
+ partitionKeys = other546.partitionKeys;
+ applyDistinct = other546.applyDistinct;
+ filter = other546.filter;
+ partitionOrder = other546.partitionOrder;
+ ascending = other546.ascending;
+ maxParts = other546.maxParts;
+ __isset = other546.__isset;
+ return *this;
+}
+void PartitionValuesRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "PartitionValuesRequest(";
+ out << "dbName=" << to_string(dbName);
+ out << ", " << "tblName=" << to_string(tblName);
+ out << ", " << "partitionKeys=" << to_string(partitionKeys);
+ out << ", " << "applyDistinct="; (__isset.applyDistinct ? (out << to_string(applyDistinct)) : (out << "<null>"));
+ out << ", " << "filter="; (__isset.filter ? (out << to_string(filter)) : (out << "<null>"));
+ out << ", " << "partitionOrder="; (__isset.partitionOrder ? (out << to_string(partitionOrder)) : (out << "<null>"));
+ out << ", " << "ascending="; (__isset.ascending ? (out << to_string(ascending)) : (out << "<null>"));
+ out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "<null>"));
+ out << ")";
+}
+
+
+PartitionValuesRow::~PartitionValuesRow() throw() {
+}
+
+
+void PartitionValuesRow::__set_row(const std::vector<std::string> & val) {
+ this->row = val;
+}
+
+uint32_t PartitionValuesRow::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_row = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->row.clear();
+ uint32_t _size547;
+ ::apache::thrift::protocol::TType _etype550;
+ xfer += iprot->readListBegin(_etype550, _size547);
+ this->row.resize(_size547);
+ uint32_t _i551;
+ for (_i551 = 0; _i551 < _size547; ++_i551)
+ {
+ xfer += iprot->readString(this->row[_i551]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_row = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_row)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t PartitionValuesRow::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("PartitionValuesRow");
+
+ xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->row.size()));
+ std::vector<std::string> ::const_iterator _iter552;
+ for (_iter552 = this->row.begin(); _iter552 != this->row.end(); ++_iter552)
+ {
+ xfer += oprot->writeString((*_iter552));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionValuesRow &a, PartitionValuesRow &b) {
+ using ::std::swap;
+ swap(a.row, b.row);
+}
+
+PartitionValuesRow::PartitionValuesRow(const PartitionValuesRow& other553) {
+ row = other553.row;
+}
+PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other554) {
+ row = other554.row;
+ return *this;
+}
+void PartitionValuesRow::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "PartitionValuesRow(";
+ out << "row=" << to_string(row);
+ out << ")";
+}
+
+
+PartitionValuesResponse::~PartitionValuesResponse() throw() {
+}
+
+
+void PartitionValuesResponse::__set_partitionValues(const std::vector<PartitionValuesRow> & val) {
+ this->partitionValues = val;
+}
+
+uint32_t PartitionValuesResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_partitionValues = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->partitionValues.clear();
+ uint32_t _size555;
+ ::apache::thrift::protocol::TType _etype558;
+ xfer += iprot->readListBegin(_etype558, _size555);
+ this->partitionValues.resize(_size555);
+ uint32_t _i559;
+ for (_i559 = 0; _i559 < _size555; ++_i559)
+ {
+ xfer += this->partitionValues[_i559].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_partitionValues = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_partitionValues)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t PartitionValuesResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("PartitionValuesResponse");
+
+ xfer += oprot->writeFieldBegin("partitionValues", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionValues.size()));
+ std::vector<PartitionValuesRow> ::const_iterator _iter560;
+ for (_iter560 = this->partitionValues.begin(); _iter560 != this->partitionValues.end(); ++_iter560)
+ {
+ xfer += (*_iter560).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionValuesResponse &a, PartitionValuesResponse &b) {
+ using ::std::swap;
+ swap(a.partitionValues, b.partitionValues);
+}
+
+PartitionValuesResponse::PartitionValuesResponse(const PartitionValuesResponse& other561) {
+ partitionValues = other561.partitionValues;
+}
+PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other562) {
+ partitionValues = other562.partitionValues;
+ return *this;
+}
+void PartitionValuesResponse::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "PartitionValuesResponse(";
+ out << "partitionValues=" << to_string(partitionValues);
+ out << ")";
+}
+
+
ResourceUri::~ResourceUri() throw() {
}
@@ -12325,9 +12822,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast533;
- xfer += iprot->readI32(ecast533);
- this->resourceType = (ResourceType::type)ecast533;
+ int32_t ecast563;
+ xfer += iprot->readI32(ecast563);
+ this->resourceType = (ResourceType::type)ecast563;
this->__isset.resourceType = true;
} else {
xfer += iprot->skip(ftype);
@@ -12378,15 +12875,15 @@ void swap(ResourceUri &a, ResourceUri &b) {
swap(a.__isset, b.__isset);
}
-ResourceUri::ResourceUri(const ResourceUri& other534) {
- resourceType = other534.resourceType;
- uri = other534.uri;
- __isset = other534.__isset;
+ResourceUri::ResourceUri(const ResourceUri& other564) {
+ resourceType = other564.resourceType;
+ uri = other564.uri;
+ __isset = other564.__isset;
}
-ResourceUri& ResourceUri::operator=(const ResourceUri& other535) {
- resourceType = other535.resourceType;
- uri = other535.uri;
- __isset = other535.__isset;
+ResourceUri& ResourceUri::operator=(const ResourceUri& other565) {
+ resourceType = other565.resourceType;
+ uri = other565.uri;
+ __isset = other565.__isset;
return *this;
}
void ResourceUri::printTo(std::ostream& out) const {
@@ -12489,9 +12986,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast536;
- xfer += iprot->readI32(ecast536);
- this->ownerType = (PrincipalType::type)ecast536;
+ int32_t ecast566;
+ xfer += iprot->readI32(ecast566);
+ this->ownerType = (PrincipalType::type)ecast566;
this->__isset.ownerType = true;
} else {
xfer += iprot->skip(ftype);
@@ -12507,9 +13004,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 7:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast537;
- xfer += iprot->readI32(ecast537);
- this->functionType = (FunctionType::type)ecast537;
+ int32_t ecast567;
+ xfer += iprot->readI32(ecast567);
+ this->functionType = (FunctionType::type)ecast567;
this->__isset.functionType = true;
} else {
xfer += iprot->skip(ftype);
@@ -12519,14 +13016,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->resourceUris.clear();
- uint32_t _size538;
- ::apache::thrift::protocol::TType _etype541;
- xfer += iprot->readListBegin(_etype541, _size538);
- this->resourceUris.resize(_size538);
- uint32_t _i542;
- for (_i542 = 0; _i542 < _size538; ++_i542)
+ uint32_t _size568;
+ ::apache::thrift::protocol::TType _etype571;
+ xfer += iprot->readListBegin(_etype571, _size568);
+ this->resourceUris.resize(_size568);
+ uint32_t _i572;
+ for (_i572 = 0; _i572 < _size568; ++_i572)
{
- xfer += this->resourceUris[_i542].read(iprot);
+ xfer += this->resourceUris[_i572].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12583,10 +13080,10 @@ uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->resourceUris.size()));
- std::vector<ResourceUri> ::const_iterator _iter543;
- for (_iter543 = this->resourceUris.begin(); _iter543 != this->resourceUris.end(); ++_iter543)
+ std::vector<ResourceUri> ::const_iterator _iter573;
+ for (_iter573 = this->resourceUris.begin(); _iter573 != this->resourceUris.end(); ++_iter573)
{
- xfer += (*_iter543).write(oprot);
+ xfer += (*_iter573).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12610,27 +13107,27 @@ void swap(Function &a, Function &b) {
swap(a.__isset, b.__isset);
}
-Function::Function(const Function& other544) {
- functionName = other544.functionName;
- dbName = other544.dbName;
- className = other544.className;
- ownerName = other544.ownerName;
- ownerType = other544.ownerType;
- createTime = other544.createTime;
- functionType = other544.functionType;
- resourceUris = other544.resourceUris;
- __isset = other544.__isset;
-}
-Function& Function::operator=(const Function& other545) {
- functionName = other545.functionName;
- dbName = other545.dbName;
- className = other545.className;
- ownerName = other545.ownerName;
- ownerType = other545.ownerType;
- createTime = other545.createTime;
- functionType = other545.functionType;
- resourceUris = other545.resourceUris;
- __isset = other545.__isset;
+Function::Function(const Function& other574) {
+ functionName = other574.functionName;
+ dbName = other574.dbName;
+ className = other574.className;
+ ownerName = other574.ownerName;
+ ownerType = other574.ownerType;
+ createTime = other574.createTime;
+ functionType = other574.functionType;
+ resourceUris = other574.resourceUris;
+ __isset = other574.__isset;
+}
+Function& Function::operator=(const Function& other575) {
+ functionName = other575.functionName;
+ dbName = other575.dbName;
+ className = other575.className;
+ ownerName = other575.ownerName;
+ ownerType = other575.ownerType;
+ createTime = other575.createTime;
+ functionType = other575.functionType;
+ resourceUris = other575.resourceUris;
+ __isset = other575.__isset;
return *this;
}
void Function::printTo(std::ostream& out) const {
@@ -12728,9 +13225,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast546;
- xfer += iprot->readI32(ecast546);
- this->state = (TxnState::type)ecast546;
+ int32_t ecast576;
+ xfer += iprot->readI32(ecast576);
+ this->state = (TxnState::type)ecast576;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -12877,29 +13374,29 @@ void swap(TxnInfo &a, TxnInfo &b) {
swap(a.__isset, b.__isset);
}
-TxnInfo::TxnInfo(const TxnInfo& other547) {
- id = other547.id;
- state = other547.state;
- user = other547.user;
- hostname = other547.hostname;
- agentInfo = other547.agentInfo;
- heartbeatCount = other547.heartbeatCount;
- metaInfo = other547.metaInfo;
- startedTime = other547.startedTime;
- lastHeartbeatTime = other547.lastHeartbeatTime;
- __isset = other547.__isset;
-}
-TxnInfo& TxnInfo::operator=(const TxnInfo& other548) {
- id = other548.id;
- state = other548.state;
- user = other548.user;
- hostname = other548.hostname;
- agentInfo = other548.agentInfo;
- heartbeatCount = other548.heartbeatCount;
- metaInfo = other548.metaInfo;
- startedTime = other548.startedTime;
- lastHeartbeatTime = other548.lastHeartbeatTime;
- __isset = other548.__isset;
+TxnInfo::TxnInfo(const TxnInfo& other577) {
+ id = other577.id;
+ state = other577.state;
+ user = other577.user;
+ hostname = other577.hostname;
+ agentInfo = other577.agentInfo;
+ heartbeatCount = other577.heartbeatCount;
+ metaInfo = other577.metaInfo;
+ startedTime = other577.startedTime;
+ lastHeartbeatTime = other577.lastHeartbeatTime;
+ __isset = other577.__isset;
+}
+TxnInfo& TxnInfo::operator=(const TxnInfo& other578) {
+ id = other578.id;
+ state = other578.state;
+ user = other578.user;
+ hostname = other578.hostname;
+ agentInfo = other578.agentInfo;
+ heartbeatCount = other578.heartbeatCount;
+ metaInfo = other578.metaInfo;
+ startedTime = other578.startedTime;
+ lastHeartbeatTime = other578.lastHeartbeatTime;
+ __isset = other578.__isset;
return *this;
}
void TxnInfo::printTo(std::ostream& out) const {
@@ -12965,14 +13462,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->open_txns.clear();
- uint32_t _size549;
- ::apache::thrift::protocol::TType _etype552;
- xfer += iprot->readListBegin(_etype552, _size549);
- this->open_txns.resize(_size549);
- uint32_t _i553;
- for (_i553 = 0; _i553 < _size549; ++_i553)
+ uint32_t _size579;
+ ::apache::thrift::protocol::TType _etype582;
+ xfer += iprot->readListBegin(_etype582, _size579);
+ this->open_txns.resize(_size579);
+ uint32_t _i583;
+ for (_i583 = 0; _i583 < _size579; ++_i583)
{
- xfer += this->open_txns[_i553].read(iprot);
+ xfer += this->open_txns[_i583].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -13009,10 +13506,10 @@ uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* o
xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->open_txns.size()));
- std::vector<TxnInfo> ::const_iterator _iter554;
- for (_iter554 = this->open_txns.begin(); _iter554 != this->open_txns.end(); ++_iter554)
+ std::vector<TxnInfo> ::const_iterator _iter584;
+ for (_iter584 = this->open_txns.begin(); _iter584 != this->open_txns.end(); ++_iter584)
{
- xfer += (*_iter554).write(oprot);
+ xfer += (*_iter584).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13029,13 +13526,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) {
swap(a.open_txns, b.open_txns);
}
-GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other555) {
- txn_high_water_mark = other555.txn_high_water_mark;
- open_txns = other555.open_txns;
+GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other585) {
+ txn_high_water_mark = other585.txn_high_water_mark;
+ open_txns = other585.open_txns;
}
-GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other556) {
- txn_high_water_mark = other556.txn_high_water_mark;
- open_txns = other556.open_txns;
+GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other586) {
+ txn_high_water_mark = other586.txn_high_water_mark;
+ open_txns = other586.open_txns;
return *this;
}
void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const {
@@ -13104,14 +13601,14 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->open_txns.clear();
- uint32_t _size557;
- ::apache::thrift::protocol::TType _etype560;
- xfer += iprot->readListBegin(_etype560, _size557);
- this->open_txns.resize(_size557);
- uint32_t _i561;
- for (_i561 = 0; _i561 < _size557; ++_i561)
+ uint32_t _size587;
+ ::apache::thrift::protocol::TType _etype590;
+ xfer += iprot->readListBegin(_etype590, _size587);
+ this->open_txns.resize(_size587);
+ uint32_t _i591;
+ for (_i591 = 0; _i591 < _size587; ++_i591)
{
- xfer += iprot->readI64(this->open_txns[_i561]);
+ xfer += iprot->readI64(this->open_txns[_i591]);
}
xfer += iprot->readListEnd();
}
@@ -13166,10 +13663,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size()));
- std::vector<int64_t> ::const_iterator _iter562;
- for (_iter562 = this->open_txns.begin(); _iter562 != this->open_txns.end(); ++_iter562)
+ std::vector<int64_t> ::const_iterator _iter592;
+ for (_iter592 = this->open_txns.begin(); _iter592 != this->open_txns.end(); ++_iter592)
{
- xfer += oprot->writeI64((*_iter562));
+ xfer += oprot->writeI64((*_iter592));
}
xfer += oprot->writeListEnd();
}
@@ -13198,19 +13695,19 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) {
swap(a.__isset, b.__isset);
}
-GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other563) {
- txn_high_water_mark = other563.txn_high_water_mark;
- open_txns = other563.open_txns;
- min_open_txn = other563.min_open_txn;
- abortedBits = other563.abortedBits;
- __isset = other563.__isset;
+GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other593) {
+ txn_high_water_mark = other593.txn_high_water_mark;
+ open_txns = other593.open_txns;
+ min_open_txn = other593.min_open_txn;
+ abortedBits = other593.abortedBits;
+ __isset = other593.__isset;
}
-GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other564) {
- txn_high_water_mark = other564.txn_high_water_mark;
- open_txns = other564.open_txns;
- min_open_txn = other564.min_open_txn;
- abortedBits = other564.abortedBits;
- __isset = other564.__isset;
+GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other594) {
+ txn_high_water_mark = other594.txn_high_water_mark;
+ open_txns = other594.open_txns;
+ min_open_txn = other594.min_open_txn;
+ abortedBits = other594.abortedBits;
+ __isset = other594.__isset;
return *this;
}
void GetOpenTxnsResponse::printTo(std::ostream& out) const {
@@ -13355,19 +13852,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) {
swap(a.__isset, b.__isset);
}
-OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other565) {
- num_txns = other565.num_txns;
- user = other565.user;
- hostname = other565.hostname;
- agentInfo = other565.agentInfo;
- __isset = other565.__isset;
+OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other595) {
+ num_txns = other595.num_txns;
+ user = other595.user;
+ hostname = other595.hostname;
+ agentInfo = other595.agentInfo;
+ __isset = other595.__isset;
}
-OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other566) {
- num_txns = other566.num_txns;
- user = other566.user;
- hostname = other566.hostname;
- agentInfo = other566.agentInfo;
- __isset = other566.__isset;
+OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other596) {
+ num_txns = other596.num_txns;
+ user = other596.user;
+ hostname = other596.hostname;
+ agentInfo = other596.agentInfo;
+ __isset = other596.__isset;
return *this;
}
void OpenTxnRequest::printTo(std::ostream& out) const {
@@ -13415,14 +13912,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- uint32_t _size567;
- ::apache::thrift::protocol::TType _etype570;
- xfer += iprot->readListBegin(_etype570, _size567);
- this->txn_ids.resize(_size567);
- uint32_t _i571;
- for (_i571 = 0; _i571 < _size567; ++_i571)
+ uint32_t _size597;
+ ::apache::thrift::protocol::TType _etype600;
+ xfer += iprot->readListBegin(_etype600, _size597);
+ this->txn_ids.resize(_size597);
+ uint32_t _i601;
+ for (_i601 = 0; _i601 < _size597; ++_i601)
{
- xfer += iprot->readI64(this->txn_ids[_i571]);
+ xfer += iprot->readI64(this->txn_ids[_i601]);
}
xfer += iprot->readListEnd();
}
@@ -13453,10 +13950,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txn_ids.size()));
- std::vector<int64_t> ::const_iterator _iter572;
- for (_iter572 = this->txn_ids.begin(); _iter572 != this->txn_ids.end(); ++_iter572)
+ std::vector<int64_t> ::const_iterator _iter602;
+ for (_iter602 = this->txn_ids.begin(); _iter602 != this->txn_ids.end(); ++_iter602)
{
- xfer += oprot->writeI64((*_iter572));
+ xfer += oprot->writeI64((*_iter602));
}
xfer += oprot->writeListEnd();
}
@@ -13472,11 +13969,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) {
swap(a.txn_ids, b.txn_ids);
}
-OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other573) {
- txn_ids = other573.txn_ids;
+OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other603) {
+ txn_ids = other603.txn_ids;
}
-OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other574) {
- txn_ids = other574.txn_ids;
+OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other604) {
+ txn_ids = other604.txn_ids;
return *this;
}
void OpenTxnsResponse::printTo(std::ostream& out) const {
@@ -13558,11 +14055,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other575) {
- txnid = other575.txnid;
+AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other605) {
+ txnid = other605.txnid;
}
-AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other576) {
- txnid = other576.txnid;
+AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other606) {
+ txnid = other606.txnid;
return *this;
}
void AbortTxnRequest::printTo(std::ostream& out) const {
@@ -13607,14 +14104,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- uint32_t _size577;
- ::apache::thrift::protocol::TType _etype580;
- xfer += iprot->readListBegin(_etype580, _size577);
- this->txn_ids.resize(_size577);
- uint32_t _i581;
- for (_i581 = 0; _i581 < _size577; ++_i581)
+ uint32_t _size607;
+ ::apache::thrift::protocol::TType _etype610;
+ xfer += iprot->readListBegin(_etype610, _size607);
+ this->txn_ids.resize(_size607);
+ uint32_t _i611;
+ for (_i611 = 0; _i611 < _size607; ++_i611)
{
- xfer += iprot->readI64(this->txn_ids[_i581]);
+ xfer += iprot->readI64(this->txn_ids[_i611]);
}
xfer += iprot->readListEnd();
}
@@ -13645,10 +14142,10 @@ uint32_t AbortTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txn_ids.size()));
- std::vector<int64_t> ::const_iterator _iter582;
- for (_iter582 = this->txn_ids.begin(); _iter582 != this->txn_ids.end(); ++_iter582)
+ std::vector<int64_t> ::const_iterator _iter612;
+ for (_iter612 = this->txn_ids.begin(); _iter612 != this->txn_ids.end(); ++_iter612)
{
- xfer += oprot->writeI64((*_iter582));
+ xfer += oprot->writeI64((*_iter612));
}
xfer += oprot->writeListEnd();
}
@@ -13664,11 +14161,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) {
swap(a.txn_ids, b.txn_ids);
}
-AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other583) {
- txn_ids = other583.txn_ids;
+AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other613) {
+ txn_ids = other613.txn_ids;
}
-AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other584) {
- txn_ids = other584.txn_ids;
+AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other614) {
+ txn_ids = other614.txn_ids;
return *this;
}
void AbortTxnsRequest::printTo(std::ostream& out) const {
@@ -13750,11 +14247,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other585) {
- txnid = other585.txnid;
+CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other615) {
+ txnid = other615.txnid;
}
-CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other586) {
- txnid = other586.txnid;
+CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other616) {
+ txnid = other616.txnid;
return *this;
}
void CommitTxnRequest::printTo(std::ostream& out) const {
@@ -13832,9 +14329,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast587;
- xfer += iprot->readI32(ecast587);
- this->type = (LockType::type)ecast587;
+ int32_t ecast617;
+ xfer += iprot->readI32(ecast617);
+ this->type = (LockType::type)ecast617;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -13842,9 +14339,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast588;
- xfer += iprot->readI32(ecast588);
- this->level = (LockLevel::type)ecast588;
+ int32_t ecast618;
+ xfer += iprot->readI32(ecast618);
+ this->level = (LockLevel::type)ecast618;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -13876,9 +14373,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast589;
- xfer += iprot->readI32(ecast589);
- this->operationType = (DataOperationType::type)ecast589;
+ int32_t ecast619;
+ xfer += iprot->readI32(ecast619);
+ this->operationType = (DataOperationType::type)ecast619;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -13978,27 +14475,27 @@ void swap(LockComponent &a, LockComponent &b) {
swap(a.__isset, b.__isset);
}
-LockComponent::LockComponent(const LockComponent& other590) {
- type = other590.type;
- level = other590.level;
- dbname = other590.dbname;
- tablename = other590.tablename;
- partitionname = other590.partitionname;
- operationType = other590.operationType;
- isAcid = other590.isAcid;
- isDynamicPartitionWrite = other590.isDynamicPartitionWrite;
- __isset = other590.__isset;
-}
-LockComponent& LockComponent::operator=(const LockComponent& other591) {
- type = other591.type;
- level = other591.level;
- dbname = other591.dbname;
- tablename = other591.tablename;
- partitionname = other591.partitionname;
- operationType = other591.operationType;
- isAcid = other591.isAcid;
- isDynamicPartitionWrite = other591.isDynamicPartitionWrite;
- __isset = other591.__isset;
+LockComponent::LockComponent(const LockComponent& other620) {
+ type = other620.type;
+ level = other620.level;
+ dbname = other620.dbname;
+ tablename = other620.tablename;
+ partitionname = other620.partitionname;
+ operationType = other620.operationType;
+ isAcid = other620.isAcid;
+ isDynamicPartitionWrite = other620.isDynamicPartitionWrite;
+ __isset = other620.__isset;
+}
+LockComponent& LockComponent::operator=(const LockComponent& other621) {
+ type = other621.type;
+ level = other621.level;
+ dbname = other621.dbname;
+ tablename = other621.tablename;
+ partitionname = other621.partitionname;
+ operationType = other621.operationType;
+ isAcid = other621.isAcid;
+ isDynamicPartitionWrite = other621.isDynamicPartitionWrite;
+ __isset = other621.__isset;
return *this;
}
void LockComponent::printTo(std::ostream& out) const {
@@ -14070,14 +14567,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- uint32_t _size592;
- ::apache::thrift::protocol::TType _etype595;
- xfer += iprot->readListBegin(_etype595, _size592);
- this->component.resize(_size592);
- uint32_t _i596;
- for (_i596 = 0; _i596 < _size592; ++_i596)
+ uint32_t _size622;
+ ::apache::thrift::protocol::TType _etype625;
+ xfer += iprot->readListBegin(_etype625, _size622);
+ this->component.resize(_size622);
+ uint32_t _i626;
+ for (_i626 = 0; _i626 < _size622; ++_i626)
{
- xfer += this->component[_i596].read(iprot);
+ xfer += this->component[_i626].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -14144,10 +14641,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const
xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->component.size()));
- std::vector<LockComponent> ::const_iterator _iter597;
- for (_iter597 = this->component.begin(); _iter597 != this->component.end(); ++_iter597)
+ std::vector<LockComponent> ::const_iterator _iter627;
+ for (_iter627 = this->component.begin(); _iter627 != this->component.end(); ++_iter627)
{
- xfer += (*_iter597).write(oprot);
+ xfer += (*_iter627).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -14186,21 +14683,21 @@ void swap(LockRequest &a, LockRequest &b) {
swap(a.__isset, b.__isset);
}
-LockRequest::LockRequest(const LockRequest& other598) {
- component = other598.component;
- txnid = other598.txnid;
- user = other598.user;
- hostname = other598.hostname;
- agentInfo = other598.agentInfo;
- __isset = other598.__isset;
-}
-LockRequest& LockRequest::operator=(const LockRequest& other599) {
- component = other599.component;
- txnid = other599.txnid;
- user = other599.user;
- hostname = other599.hostname;
- agentInfo = other599.agentInfo;
- __isset = other599.__isset;
+LockRequest::LockRequest(const LockRequest& other628) {
+ component = other628.component;
+ txnid = other628.txnid;
+ user = other628.user;
+ hostname = other628.hostname;
+ agentInfo = other628.agentInfo;
+ __isset = other628.__isset;
+}
+LockRequest& LockRequest::operator=(const LockRequest& other629) {
+ component = other629.component;
+ txnid = other629.txnid;
+ user = other629.user;
+ hostname = other629.hostname;
+ agentInfo = other629.agentInfo;
+ __isset = other629.__isset;
return *this;
}
void LockRequest::printTo(std::ostream& out) const {
@@ -14260,9 +14757,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast600;
- xfer += iprot->readI32(ecast600);
- this->state = (LockState::type)ecast600;
+ int32_t ecast630;
+ xfer += iprot->readI32(ecast630);
+ this->state = (LockState::type)ecast630;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -14308,13 +14805,13 @@ void swap(LockResponse &a, LockResponse &b) {
swap(a.state, b.state);
}
-LockResponse::LockResponse(const LockResponse& other601) {
- lockid = other601.lockid;
- state = other601.state;
+LockResponse::LockResponse(const LockResponse& other631) {
+ lockid = other631.lockid;
+ state = other631.state;
}
-LockResponse& LockResponse::operator=(const LockResponse& other602) {
- lockid = other602.lockid;
- state = other602.state;
+LockResponse& LockResponse::operator=(const LockResponse& other632) {
+ lockid = other632.lockid;
+ state = other632.state;
return *this;
}
void LockResponse::printTo(std::ostream& out) const {
@@ -14436,17 +14933,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) {
swap(a.__isset, b.__isset);
}
-CheckLockRequest::CheckLockRequest(const CheckLockRequest& other603) {
- lockid = other603.lockid;
- txnid = other603.txnid;
- elapsed_ms = other603.elapsed_ms;
- __isset = other603.__isset;
+CheckLockRequest::CheckLockRequest(const CheckLockRequest& other633) {
+ lockid = other633.lockid;
+ txnid = other633.txnid;
+ elapsed_ms = other633.elapsed_ms;
+ __isset = other633.__isset;
}
-CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other604) {
- lockid = other604.lockid;
- txnid = other604.txnid;
- elapsed_ms = other604.elapsed_ms;
- __isset = other604.__isset;
+CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other634) {
+ lockid = other634.lockid;
+ txnid = other634.txnid;
+ elapsed_ms = other634.elapsed_ms;
+ __isset = other634.__isset;
return *this;
}
void CheckLockRequest::printTo(std::ostream& out) const {
@@ -14530,11 +15027,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) {
swap(a.lockid, b.lockid);
}
-UnlockRequest::UnlockRequest(const UnlockRequest& other605) {
- lockid = other605.lockid;
+UnlockRequest::UnlockRequest(const UnlockRequest& other635) {
+ lockid = other635.lockid;
}
-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other606) {
- lockid = other606.lockid;
+UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other636) {
+ lockid = other636.lockid;
return *this;
}
void UnlockRequest::printTo(std::ostream& out) const {
@@ -14673,19 +15170,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other607) {
- dbname = other607.dbname;
- tablename = other607.tablename;
- partname = other607.partname;
- isExtended = other607.isExtended;
- __isset = other607.__isset;
+ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other637) {
+ dbname = other637.dbname;
+ tablename = other637.tablename;
+ partname = other637.partname;
+ isExtended = other637.isExtended;
+ __isset = other637.__isset;
}
-ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other608) {
- dbname = other608.dbname;
- tablename = other608.tablename;
- partname = other608.partname;
- isExtended = other608.isExtended;
- __isset = other608.__isset;
+ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other638) {
+ dbname = other638.dbname;
+ tablename = other638.tablename;
+ partname = other638.partname;
+ isExtended = other638.isExtended;
+ __isset = other638.__isset;
return *this;
}
void ShowLocksRequest::printTo(std::ostream& out) const {
@@ -14838,9 +15335,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast609;
- xfer += iprot->readI32(ecast609);
- this->state = (LockState::type)ecast609;
+ int32_t ecast639;
+ xfer += iprot->readI32(ecast639);
+ this->state = (LockState::type)ecast639;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -14848,9 +15345,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast610;
- xfer += iprot->readI32(ecast610);
- this->type = (LockType::type)ecast610;
+ int32_t ecast640;
+ xfer += iprot->readI32(ecast640);
+ this->type = (LockType::type)ecast640;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -15066,43 +15563,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other611) {
- lockid = other611.lockid;
- dbname = other611.dbname;
- tablename = other611.tablename;
- partname = other611.partname;
- state = other611.state;
- type = other611.type;
- txnid = other611.txnid;
- lastheartbeat = other611.lastheartbeat;
- acquiredat = other611.acquiredat;
- user = other611.user;
- hostname = other611.hostname;
- heartbeatCount = other611.heartbeatCount;
- agentInfo = other611.agentInfo;
- blockedByExtId = other611.blockedByExtId;
- blockedByIntId = other611.blockedByIntId;
- lockIdInternal = other611.lockIdInternal;
- __isset = other611.__isset;
-}
-ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other612) {
- lockid = other612.lockid;
- dbname = other612.dbname;
- tablename = other612.tablename;
- partname = other612.partname;
- state = other612.state;
- type = other612.type;
- txnid = other612.txnid;
- lastheartbeat = other612.lastheartbeat;
- acquiredat = other612.acquiredat;
- user = other612.user;
- hostname = other612.hostname;
- heartbeatCount = other612.heartbeatCount;
- agentInfo = other612.agentInfo;
- blockedByExtId = other612.blockedByExtId;
- blockedByIntId = other612.blockedByIntId;
- lockIdInternal = other612.lockIdInternal;
- __isset = other612.__isset;
+ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other641) {
+ lockid = other641.lockid;
+ dbname = other641.dbname;
+ tablename = other641.tablename;
+ partname = other641.partname;
+ state = other641.state;
+ type = other641.type;
+ txnid = other641.txnid;
+ lastheartbeat = other641.lastheartbeat;
+ acquiredat = other641.acquiredat;
+ user = other641.user;
+ hostname = other641.hostname;
+ heartbeatCount = other641.heartbeatCount;
+ agentInfo = other641.agentInfo;
+ blockedByExtId = other641.blockedByExtId;
+ blockedByIntId = other641.blockedByIntId;
+ lockIdInternal = other641.lockIdInternal;
+ __isset = other641.__isset;
+}
+ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other642) {
+ lockid = other642.lockid;
+ dbname = other642.dbname;
+ tablename = other642.tablename;
+ partname = other642.partname;
+ state = other642.state;
+ type = other642.type;
+ txnid = other642.txnid;
+ lastheartbeat = other642.lastheartbeat;
+ acquiredat = other642.acquiredat;
+ user = other642.user;
+ hostname = other642.hostname;
+ heartbeatCount = other642.heartbeatCount;
+ agentInfo = other642.agentInfo;
+ blockedByExtId = other642.blockedByExtId;
+ blockedByIntId = other642.blockedByIntId;
+ lockIdInternal = other642.lockIdInternal;
+ __isset = other642.__isset;
return *this;
}
void ShowLocksResponseElement::printTo(std::ostream& out) const {
@@ -15161,14 +15658,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- uint32_t _size613;
- ::apache::thrift::protocol::TType _etype616;
- xfer += iprot->readListBegin(_etype616, _size613);
- this->locks.resize(_size613);
- uint32_t _i617;
- for (_i617 = 0; _i617 < _size613; ++_i617)
+ uint32_t _size643;
+ ::apache::thrift::protocol::TType _etype646;
+ xfer += iprot->readListBegin(_etype646, _size643);
+ this->locks.resize(_size643);
+ uint32_t _i647;
+ for (_i647 = 0; _i647 < _size643; ++_i647)
{
- xfer += this->locks[_i617].read(iprot);
+ xfer += this->locks[_i647].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -15197,10 +15694,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->locks.size()));
- std::vector<ShowLocksResponseElement> ::const_iterator _iter618;
- for (_iter618 = this->locks.begin(); _iter618 != this->locks.end(); ++_iter618)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter648;
+ for (_iter648 = this->locks.begin(); _iter648 != this->locks.end(); ++_iter648)
{
- xfer += (*_iter618).write(oprot);
+ xfer += (*_iter648).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -15217,13 +15714,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other619) {
- locks = other619.locks;
- __isset = other619.__isset;
+ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other649) {
+ locks = other649.locks;
+ __isset = other649.__isset;
}
-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other620) {
- locks = other620.locks;
- __isset = other620.__isset;
+ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other650) {
+ locks = other650.locks;
+ __isset = other650.__isset;
return *this;
}
void ShowLocksResponse::printTo(std::ostream& out) const {
@@ -15324,15 +15821,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) {
swap(a.__isset, b.__isset);
}
-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other621) {
- lockid = other621.lockid;
- txnid = other621.txnid;
- __isset = other621.__isset;
+HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other651) {
+ lockid = other651.lockid;
+ txnid = other651.txnid;
+ __isset = other651.__isset;
}
-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other622) {
- lockid = other622.lockid;
- txnid = other622.txnid;
- __isset = other622.__isset;
+HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other652) {
+ lockid = other652.lockid;
+ txnid = other652.txnid;
+ __isset = other652.__isset;
return *this;
}
void HeartbeatRequest::printTo(std::ostream& out) const {
@@ -15435,13 +15932,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) {
swap(a.max, b.max);
}
-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other623) {
- min = other623.min;
- max = other623.max;
+HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other653) {
+ min = other653.min;
+ max = other653.max;
}
-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other624) {
- min = other624.min;
- max = other624.max;
+HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other654) {
+ min = other654.min;
+ max = other654.max;
return *this;
}
void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const {
@@ -15492,15 +15989,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size625;
- ::apache::thrift::protocol::TType _etype628;
- xfer += iprot->readSetBegin(_etype628, _size625);
- uint32_t _i629;
- for (_i629 = 0; _i629 < _size625; ++_i629)
+ uint32_t _size655;
+ ::apache::thrift::protocol::TType _etype658;
+ xfer += iprot->readSetBegin(_etype658, _size655);
+ uint32_t _i659;
+ for (_i659 = 0; _i659 < _size655; ++_i659)
{
- int64_t _elem630;
- xfer += iprot->readI64(_elem630);
- this->aborted.insert(_elem630);
+ int64_t _elem660;
+ xfer += iprot->readI64(_elem660);
+ this->aborted.insert(_elem660);
}
xfer += iprot->readSetEnd();
}
@@ -15513,15 +16010,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size631;
- ::apache::thrift::protocol::TType _etype634;
- xfer += iprot->readSetBegin(_etype634, _size631);
- uint32_t _i635;
- for (_i635 = 0; _i635 < _size631; ++_i635)
+ uint32_t _size661;
+ ::apache::thrift::protocol::TType _etype664;
+ xfer += iprot->readSetBegin(_etype664, _size661);
+ uint32_t _i665;
+ for (_i665 = 0; _i665 < _size661; ++_i665)
{
- int64_t _elem636;
- xfer += iprot->readI64(_elem636);
- this->nosuch.insert(_elem636);
+ int64_t _elem666;
+ xfer += iprot->readI64(_elem666);
+ this->nosuch.insert(_elem666);
}
xfer += iprot->readSetEnd();
}
@@ -15554,10 +16051,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->aborted.size()));
- std::set<int64_t> ::const_iterator _iter637;
- for (_iter637 = this->aborted.begin(); _iter637 != this->aborted.end(); ++_iter637)
+ std::set<int64_t> ::const_iterator _iter667;
+ for (_iter667 = this->aborted.begin(); _iter667 != this->aborted.end(); ++_iter667)
{
- xfer += oprot->writeI64((*_iter637));
+ xfer += oprot->writeI64((*_iter667));
}
xfer += oprot->writeSetEnd();
}
@@ -15566,10 +16063,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->nosuch.size()));
- std::set<int64_t> ::const_iterator _iter638;
- for (_iter638 = this->nosuch.begin(); _iter638 != this->nosuch.end(); ++_iter638)
+ std::set<int64_t> ::const_iterator _iter668;
+ for (_iter668 = this->nosuch.begin(); _iter668 != this->nosuch.end(); ++_iter668)
{
- xfer += oprot->writeI64((*_iter638));
+ xfer += oprot->writeI64((*_iter668));
}
xfer += oprot->writeSetEnd();
}
@@ -15586,13 +16083,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) {
swap(a.nosuch, b.nosuch);
}
-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other639) {
- aborted = other639.aborted;
- nosuch = other639.nosuch;
+HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other669) {
+ aborted = other669.aborted;
+ nosuch = other669.nosuch;
}
-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other640) {
- aborted = other640.aborted;
- nosuch = other640.nosuch;
+HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other670) {
+ aborted = other670.aborted;
+ nosuch = other670.nosuch;
return *this;
}
void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const {
@@ -15685,9 +16182,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast641;
- xfer += iprot->readI32(ecast641);
- this->type = (CompactionType::type)ecast641;
+ int32_t ecast671;
+ xfer += iprot->readI32(ecast671);
+ this->type = (CompactionType::type)ecast671;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -15705,17 +16202,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size642;
- ::apache::thrift::protocol::TType _ktype643;
- ::apache::thrift::protocol::TType _vtype644;
- xfer += iprot->readMapBegin(_ktype643, _vtype644, _size642);
- uint32_t _i646;
- for (_i646 = 0; _i646 < _size642; ++_i646)
+ uint32_t _size672;
+ ::apache::thrift::protocol::TType _ktype673;
+ ::apache::thrift::protocol::TType _vtype674;
+ xfer += iprot->readMapBegin(_ktype673, _vtype674, _size672);
+ uint32_t _i676;
+ for (_i676 = 0; _i676 < _size672; ++_i676)
{
- std::string _key647;
- xfer += iprot->readString(_key647);
- std::string& _val648 = this->properties[_key647];
- xfer += iprot->readString(_val648);
+ std::string _key677;
+ xfer += iprot->readString(_key677);
+ std::string& _val678 = this->properties[_key677];
+ xfer += iprot->readString(_val678);
}
xfer += iprot->readMapEnd();
}
@@ -15773,11 +16270,11 @@ uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6);
{
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 _iter649;
- for (_iter649 = this->properties.begin(); _iter649 != this->properties.end(); ++_iter649)
+ std::map<std::string, std::string> ::const_iterator _iter679;
+ for (_iter679 = this->properties.begin(); _iter679 != this->properties.end(); ++_iter679)
{
- xfer += oprot->writeString(_iter649->first);
- xfer += oprot->writeString(_iter649->second);
+ xfer += oprot->writeString(_iter679->first);
+ xfer += oprot->writeString(_iter679->second);
}
xfer += oprot->writeMapEnd();
}
@@ -15799,23 +16296,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) {
swap(a.__isset, b.__isset);
}
-CompactionRequest::CompactionRequest(const CompactionRequest& other650) {
- dbname = other650.dbname;
- tablename = other650.tablename;
- partitionname = other650.partitionname;
- type = other650.type;
- runas = other650.runas;
- properties = other650.properties;
- __isset = other650.__isset;
-}
-CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other651) {
- dbname = other651.dbname;
- tablename = other651.tablename;
- partitionname = other651.partitionname;
- type = other651.type;
- runas = other651.runas;
- properties = other651.properties;
- __isset = other651.__isset;
+CompactionRequest::CompactionRequest(const CompactionRequest& other680) {
+ dbname = other680.dbname;
+ tablename = other680.tablename;
+ partitionname = other680.partitionname;
+ type = other680.type;
+ runas = other680.runas;
+ properties = other680.properties;
+ __isset = other680.__isset;
+}
+CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other681) {
+ dbname = other681.dbname;
+ tablename = other681.tablename;
+ partitionname = other681.partitionname;
+ type = other681.type;
+ runas = other681.runas;
+ properties = other681.properties;
+ __isset = other681.__isset;
return *this;
}
void CompactionRequest::printTo(std::ostream& out) const {
@@ -15942,15 +16439,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) {
swap(a.accepted, b.accepted);
}
-CompactionResponse::CompactionResponse(const CompactionResponse& other652) {
- id = other652.id;
- state = other652.state;
- accepted = other652.accepted;
+CompactionResponse::CompactionResponse(const CompactionResponse& other682) {
+ id = other682.id;
+ state = other682.state;
+ accepted = other682.accepted;
}
-CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other653) {
- id = other653.id;
- state = other653.state;
- accepted = other653.accepted;
+CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other683) {
+ id = other683.id;
+ state = other683.state;
+ accepted = other683.accepted;
return *this;
}
void CompactionResponse::printTo(std::ostream& out) const {
@@ -16011,11 +16508,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) {
(void) b;
}
-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other654) {
- (void) other654;
+ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other684) {
+ (void) other684;
}
-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other655) {
- (void) other655;
+ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other685) {
+ (void) other685;
return *this;
}
void ShowCompactRequest::printTo(std::ostream& out) const {
@@ -16141,9 +16638,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol*
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast656;
- xfer += iprot->readI32(ecast656);
- this->type = (CompactionType::type)ecast656;
+ int32_t ecast686;
+ xfer += iprot->readI32(ecast686);
+ this->type = (CompactionType::type)ecast686;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -16330,37 +16827,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other657) {
- dbname = other657.dbname;
- tablename = other657.tablename;
- partitionname = other657.partitionname;
- type = other657.type;
- state = other657.state;
- workerid = other657.workerid;
- start = other657.start;
- runAs = other657.runAs;
- hightestTxnId = other657.hightestTxnId;
- metaInfo = other657.metaInfo;
- endTime = other657.endTime;
- hadoopJobId = other657.hadoopJobId;
- id = other657.id;
- __isset = other657.__isset;
-}
-ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other658) {
- dbname = other658.dbname;
- tablename = other658.tablename;
- partitionname = other658.partitionname;
- type = other658.type;
- state = other658.state;
- workerid = other658.workerid;
- start = other658.start;
- runAs = other658.runAs;
- hightestTxnId = other658.hightestTxnId;
- metaInfo = other658.metaInfo;
- endTime = other658.endTime;
- hadoopJobId = other658.hadoopJobId;
- id = other658.id;
- __isset = other658.__isset;
+ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other687) {
+ dbname = other687.dbname;
+ tablename = other687.tablename;
+ partitionname = other687.partitionname;
+ type = other687.type;
+ state = other687.state;
+ workerid = other687.workerid;
+ start = other687.start;
+ runAs = other687.runAs;
+ hightestTxnId = other687.hightestTxnId;
+ metaInfo = other687.metaInfo;
+ endTime = other687.endTime;
+ hadoopJobId = other687.hadoopJobId;
+ id = other687.id;
+ __isset = other687.__isset;
+}
+ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other688) {
+ dbname = other688.dbname;
+ tablename = other688.tablename;
+ partitionname = other688.partitionname;
+ type = other688.type;
+ state = other688.state;
+ workerid = other688.workerid;
+ start = other688.start;
+ runAs = other688.runAs;
+ hightestTxnId = other688.hightestTxnId;
+ metaInfo = other688.metaInfo;
+ endTime = other688.endTime;
+ hadoopJobId = other688.hadoopJobId;
+ id = other688.id;
+ __isset = other688.__isset;
return *this;
}
void ShowCompactResponseElement::printTo(std::ostream& out) const {
@@ -16417,14 +16914,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- uint32_t _size659;
- ::apache::thrift::protocol::TType _etype662;
- xfer += iprot->readListBegin(_etype662, _size659);
- this->compacts.resize(_size659);
- uint32_t _i663;
- for (_i663 = 0; _i663 < _size659; ++_i663)
+ uint32_t _size689;
+ ::apache::thrift::protocol::TType _etype692;
+ xfer += iprot->readListBegin(_etype692, _size689);
+ this->compacts.resize(_size689);
+ uint32_t _i693;
+ for (_i693 = 0; _i693 < _size689; ++_i693)
{
- xfer += this->compacts[_i663].read(iprot);
+ xfer += this->compacts[_i693].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -16455,10 +16952,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->compacts.size()));
- std::vector<ShowCompactResponseElement> ::const_iterator _iter664;
- for (_iter664 = this->compacts.begin(); _iter664 != this->compacts.end(); ++_iter664)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter694;
+ for (_iter694 = this->compacts.begin(); _iter694 != this->compacts.end(); ++_iter694)
{
- xfer += (*_iter664).write(oprot);
+ xfer += (*_iter694).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -16474,11 +16971,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) {
swap(a.compacts, b.compacts);
}
-ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other665) {
- compacts = other665.compacts;
+ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other695) {
+ compacts = other695.compacts;
}
-ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other666) {
- compacts = other666.compacts;
+ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other696) {
+ compacts = other696.compacts;
return *this;
}
void ShowCompactResponse::printTo(std::ostream& out) const {
@@ -16567,14 +17064,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionnames.clear();
- uint32_t _size667;
- ::apache::thrift::protocol::TType _etype670;
- xfer += iprot->readListBegin(_etype670, _size667);
- this->partitionnames.resize(_size667);
- uint32_t _i671;
- for (_i671 = 0; _i671 < _size667; ++_i671)
+ uint32_t _size697;
+ ::apache::thrift::protocol::TType _etype700;
+ xfer += iprot->readListBegin(_etype700, _size697);
+ this->partitionnames.resize(_size697);
+ uint32_t _i701;
+ for (_i701 = 0; _i701 < _size697; ++_i701)
{
- xfer += iprot->readString(this->partitionnames[_i671]);
+ xfer += iprot->readString(this->partitionnames[_i701]);
}
xfer += iprot->readListEnd();
}
@@ -16585,9 +17082,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast672;
- xfer += iprot->readI32(ecast672);
- this->operationType = (DataOperationType::type)ecast672;
+ int32_t ecast702;
+ xfer += iprot->readI32(ecast702);
+ this->operationType = (DataOperationType::type)ecast702;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -16633,10 +17130,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionnames.size()));
- std::vector<std::string> ::const_iterator _iter673;
- for (_iter673 = this->partitionnames.begin(); _iter673 != this->partitionnames.end(); ++_iter673)
+ std::vector<std::string> ::const_iterator _iter703;
+ for (_iter703 = this->partitionnames.begin(); _iter703 != this->partitionnames.end(); ++_iter703)
{
- xfer += oprot->writeString((*_iter673));
+ xfer += oprot->writeString((*_iter703));
}
xfer += oprot->writeListEnd();
}
@@ -16662,21 +17159,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) {
swap(a.__isset, b.__isset);
}
-AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other674) {
- txnid = other674.txnid;
- dbname = other674.dbname;
- tablename = other674.tablename;
- partitionnames = other674.partitionnames;
- operationType = other674.operationType;
- __isset = other674.__isset;
-}
-AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other675) {
- txnid = other675.txnid;
- dbname = other675.dbname;
- tablename = other675.tablename;
- partitionnames = other675.partitionnames;
- operationType = other675.operationType;
- __isset = other675.__isset;
+AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other704) {
+ txnid = other704.txnid;
+ dbname = other704.dbname;
+ tablename = other704.tablename;
+ partitionnames = other704.partitionnames;
+ operationType = other704.operationType;
+ __isset = other704.__isset;
+}
+AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other705) {
+ txnid = other705.txnid;
+ dbname = other705.dbname;
+ tablename = other705.tablename;
+ partitionnames = other705.partitionnames;
+ operationType = other705.operationType;
+ __isset = other705.__isset;
return *this;
}
void AddDynamicPartitions::printTo(std::ostream& out) const {
@@ -16782,15 +17279,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
swap(a.__isset, b.__isset);
}
-NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other676) {
- lastEvent = other676.lastEvent;
- maxEvents = other676.maxEvents;
- __isset = other676.__isset;
+NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other706) {
+ lastEvent = other706.lastEvent;
+ maxEvents = other706.maxEvents;
+ __isset = other706.__isset;
}
-NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other677) {
- lastEvent = other677.lastEvent;
- maxEvents = other677.maxEvents;
- __isset = other677.__isset;
+NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other707) {
+ lastEvent = other707.lastEvent;
+ maxEvents = other707.maxEvents;
+ __isset = other707.__isset;
return *this;
}
void NotificationEventRequest::printTo(std::ostream& out) const {
@@ -16991,25 +17488,25 @@ void swap(NotificationEvent &a, NotificationEvent &b) {
swap(a.__isset, b.__isset);
}
-NotificationEvent::NotificationEvent(const NotificationEvent& other678) {
- eventId = other678.eventId;
- eventTime = other678.eventTime;
- eventType = other678.eventType;
- dbName = other678.dbName;
- tableName = other678.tableName;
- message = other678.message;
- messageFormat = other678.messageFormat;
- __isset = other678.__isset;
-}
-NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other679) {
- eventId = other679.eventId;
- eventTime = other679.eventTime;
- eventType = other679.eventType;
- dbName = other679.dbName;
- tableName = other679.tableName;
- message = other679.message;
- messageFormat = other679.messageFormat;
- __isset = other679.__isset;
+NotificationEvent::NotificationEvent(const NotificationEvent& other708) {
+ eventId = other708.eventId;
+ eventTime = other708.eventTime;
+ eventType = other708.eventType;
+ dbName = other708.dbName;
+ tableName = other708.tableName;
+ message = other708.message;
+ messageFormat = other708.messageFormat;
+ __isset = other708.__isset;
+}
+NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other709) {
+ eventId = other709.eventId;
+ eventTime = other709.eventTime;
+ eventType = other709.eventType;
+ dbName = other709.dbName;
+ tableName = other709.tableName;
+ message = other709.message;
+ messageFormat = other709.messageFormat;
+ __isset = other709.__isset;
return *this;
}
void NotificationEvent::printTo(std::ostream& out) const {
@@ -17060,14 +17557,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->events.clear();
- uint32_t _size680;
- ::apache::thrift::protocol::TType _etype683;
- xfer += iprot->readListBegin(_etype683, _size680);
- this->events.resize(_size680);
- uint32_t _i684;
- for (_i684 = 0; _i684 < _size680; ++_i684)
+ uint32_t _size710;
+ ::apache::thrift::protocol::TType _etype713;
+ xfer += iprot->readListBegin(_etype713, _size710);
+ this->events.resize(_size710);
+ uint32_t _i714;
+ for (_i714 = 0; _i714 < _size710; ++_i714)
{
- xfer += this->events[_i684].read(iprot);
+ xfer += this->events[_i714].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -17098,10 +17595,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->events.size()));
- std::vector<NotificationEvent> ::const_iterator _iter685;
- for (_iter685 = this->events.begin(); _iter685 != this->events.end(); ++_iter685)
+ std::vector<NotificationEvent> ::const_iterator _iter715;
+ for (_iter715 = this->events.begin(); _iter715 != this->events.end(); ++_iter715)
{
- xfer += (*_iter685).write(oprot);
+ xfer += (*_iter715).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -17117,11 +17614,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) {
swap(a.events, b.events);
}
-NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other686) {
- events = other686.events;
+NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other716) {
+ events = other716.events;
}
-NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other687) {
- events = other687.events;
+NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other717) {
+ events = other717.events;
return *this;
}
void NotificationEventResponse::printTo(std::ostream& out) const {
@@ -17203,11 +17700,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) {
swap(a.eventId, b.eventId);
}
-CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other688) {
- eventId = other688.eventId;
+CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other718) {
+ eventId = other718.eventId;
}
-CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other689) {
- eventId = other689.eventId;
+CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other719) {
+ eventId = other719.eventId;
return *this;
}
void CurrentNotificationEventId::printTo(std::ostream& out) const {
@@ -17309,13 +17806,13 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b)
swap(a.dbName, b.dbName);
}
-NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other690) {
- fromEventId = other690.fromEventId;
- dbName = other690.dbName;
+NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other720) {
+ fromEventId = other720.fromEventId;
+ dbName = other720.dbName;
}
-NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other691) {
- fromEventId = other691.fromEventId;
- dbName = other691.dbName;
+NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other721) {
+ fromEventId = other721.fromEventId;
+ dbName = other721.dbName;
return *this;
}
void NotificationEventsCountRequest::printTo(std::ostream& out) const {
@@ -17398,11 +17895,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b
swap(a.eventsCount, b.eventsCount);
}
-NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other692) {
- eventsCount = other692.eventsCount;
+NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other722) {
+ eventsCount = other722.eventsCount;
}
-NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other693) {
- eventsCount = other693.eventsCount;
+NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other723) {
+ eventsCount = other723.eventsCount;
return *this;
}
void NotificationEventsCountResponse::printTo(std::ostream& out) const {
@@ -17465,14 +17962,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAdded.clear();
- uint32_t _size694;
- ::apache::thrift::protocol::TType _etype697;
- xfer += iprot->readListBegin(_etype697, _size694);
- this->filesAdded.resize(_size694);
- uint32_t _i698;
- for (_i698 = 0; _i698 < _size694; ++_i698)
+ uint32_t _size724;
+ ::apache::thrift::protocol::TType _etype727;
+ xfer += iprot->readListBegin(_etype727, _size724);
+ this->filesAdded.resize(_size724);
+ uint32_t _i728;
+ for (_i728 = 0; _i728 < _size724; ++_i728)
{
- xfer += iprot->readString(this->filesAdded[_i698]);
+ xfer += iprot->readString(this->filesAdded[_i728]);
}
xfer += iprot->readListEnd();
}
@@ -17485,14 +17982,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAddedChecksum.clear();
- uint32_t _size699;
- ::apache::thrift::protocol::TType _etype702;
- xfer += iprot->readListBegin(_etype702, _size699);
- this->filesAddedChecksum.resize(_size699);
- uint32_t _i703;
- for (_i703 = 0; _i703 < _size699; ++_i703)
+ uint32_t _size729;
+ ::apache::thrift::protocol::TType _etype732;
+ xfer += iprot->readListBegin(_etype732, _size729);
+ this->filesAddedChecksum.resize(_size729);
+ uint32_t _i733;
+ for (_i733 = 0; _i733 < _size729; ++_i733)
{
- xfer += iprot->readString(this->filesAddedChecksum[_i703]);
+ xfer += iprot->readString(this->filesAddedChecksum[_i733]);
}
xfer += iprot->readListEnd();
}
@@ -17528,10 +18025,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAdded.size()));
- std::vector<std::string> ::const_iterator _iter704;
- for (_iter704 = this->filesAdded.begin(); _iter704 != this->filesAdded.end(); ++_iter704)
+ std::vector<std::string> ::const_iterator _iter734;
+ for (_iter734 = this->filesAdded.begin(); _iter734 != this->filesAdded.end(); ++_iter734)
{
- xfer += oprot->writeString((*_iter704));
+ xfer += oprot->writeString((*_iter734));
}
xfer += oprot->writeListEnd();
}
@@ -17541,10 +18038,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAddedChecksum.size()));
- std::vector<std::string> ::const_iterator _iter705;
- for (_iter705 = this->filesAddedChecksum.begin(); _iter705 != this->filesAddedChecksum.end(); ++_iter705)
+ std::vector<std::string> ::const_iterator _iter735;
+ for (_iter735 = this->filesAddedChecksum.begin(); _iter735 != this->filesAddedChecksum.end(); ++_iter735)
{
- xfer += oprot->writeString((*_iter705));
+ xfer += oprot->writeString((*_iter735));
}
xfer += oprot->writeListEnd();
}
@@ -17563,17 +18060,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) {
swap(a.__isset, b.__isset);
}
-InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other706) {
- replace = other706.replace;
- filesAdded = other706.filesAdded;
- filesAddedChecksum = other706.filesAddedChecksum;
- __isset = other706.__isset;
+InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other736) {
+ replace = other736.replace;
+ filesAdded = other736.filesAdded;
+ filesAddedChecksum = other736.filesAddedChecksum;
+ __isset = other736.__isset;
}
-InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other707) {
- replace = other707.replace;
- filesAdded = other707.filesAdded;
- filesAddedChecksum = other707.filesAddedChecksum;
- __isset = other707.__isset;
+InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other737) {
+ replace = other737.replace;
+ filesAdded = other737.filesAdded;
+ filesAddedChecksum = other737.filesAddedChecksum;
+ __isset = other737.__isset;
return *this;
}
void InsertEventRequestData::printTo(std::ostream& out) const {
@@ -17655,13 +18152,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) {
swap(a.__isset, b.__isset);
}
-FireEventRequestData::FireEventRequestData(const FireEventRequestData& other708) {
- insertData = other708.insertData;
- __isset = other708.__isset;
+FireEventRequestData::FireEventRequestData(const FireEventRequestData& other738) {
+ insertData = other738.insertData;
+ __isset = other738.__isset;
}
-FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other709) {
- insertData = other709.insertData;
- __isset = other709.__isset;
+FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other739) {
+ insertData = other739.insertData;
+ __isset = other739.__isset;
return *this;
}
void FireEventRequestData::printTo(std::ostream& out) const {
@@ -17758,14 +18255,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionVals.cl
<TRUNCATED>