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 21:31:52 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/dec4efd3/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index be8429e..ed847cd 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -11216,6 +11216,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 _size493;
+ ::apache::thrift::protocol::TType _etype496;
+ xfer += iprot->readListBegin(_etype496, _size493);
+ this->partitionKeys.resize(_size493);
+ uint32_t _i497;
+ for (_i497 = 0; _i497 < _size493; ++_i497)
+ {
+ xfer += this->partitionKeys[_i497].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 _size498;
+ ::apache::thrift::protocol::TType _etype501;
+ xfer += iprot->readListBegin(_etype501, _size498);
+ this->partitionOrder.resize(_size498);
+ uint32_t _i502;
+ for (_i502 = 0; _i502 < _size498; ++_i502)
+ {
+ xfer += this->partitionOrder[_i502].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 _iter503;
+ for (_iter503 = this->partitionKeys.begin(); _iter503 != this->partitionKeys.end(); ++_iter503)
+ {
+ xfer += (*_iter503).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 _iter504;
+ for (_iter504 = this->partitionOrder.begin(); _iter504 != this->partitionOrder.end(); ++_iter504)
+ {
+ xfer += (*_iter504).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& other505) {
+ dbName = other505.dbName;
+ tblName = other505.tblName;
+ partitionKeys = other505.partitionKeys;
+ applyDistinct = other505.applyDistinct;
+ filter = other505.filter;
+ partitionOrder = other505.partitionOrder;
+ ascending = other505.ascending;
+ maxParts = other505.maxParts;
+ __isset = other505.__isset;
+}
+PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other506) {
+ dbName = other506.dbName;
+ tblName = other506.tblName;
+ partitionKeys = other506.partitionKeys;
+ applyDistinct = other506.applyDistinct;
+ filter = other506.filter;
+ partitionOrder = other506.partitionOrder;
+ ascending = other506.ascending;
+ maxParts = other506.maxParts;
+ __isset = other506.__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 _size507;
+ ::apache::thrift::protocol::TType _etype510;
+ xfer += iprot->readListBegin(_etype510, _size507);
+ this->row.resize(_size507);
+ uint32_t _i511;
+ for (_i511 = 0; _i511 < _size507; ++_i511)
+ {
+ xfer += iprot->readString(this->row[_i511]);
+ }
+ 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 _iter512;
+ for (_iter512 = this->row.begin(); _iter512 != this->row.end(); ++_iter512)
+ {
+ xfer += oprot->writeString((*_iter512));
+ }
+ 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& other513) {
+ row = other513.row;
+}
+PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other514) {
+ row = other514.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 _size515;
+ ::apache::thrift::protocol::TType _etype518;
+ xfer += iprot->readListBegin(_etype518, _size515);
+ this->partitionValues.resize(_size515);
+ uint32_t _i519;
+ for (_i519 = 0; _i519 < _size515; ++_i519)
+ {
+ xfer += this->partitionValues[_i519].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 _iter520;
+ for (_iter520 = this->partitionValues.begin(); _iter520 != this->partitionValues.end(); ++_iter520)
+ {
+ xfer += (*_iter520).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& other521) {
+ partitionValues = other521.partitionValues;
+}
+PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other522) {
+ partitionValues = other522.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() {
}
@@ -11251,9 +11748,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast493;
- xfer += iprot->readI32(ecast493);
- this->resourceType = (ResourceType::type)ecast493;
+ int32_t ecast523;
+ xfer += iprot->readI32(ecast523);
+ this->resourceType = (ResourceType::type)ecast523;
this->__isset.resourceType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11304,15 +11801,15 @@ void swap(ResourceUri &a, ResourceUri &b) {
swap(a.__isset, b.__isset);
}
-ResourceUri::ResourceUri(const ResourceUri& other494) {
- resourceType = other494.resourceType;
- uri = other494.uri;
- __isset = other494.__isset;
+ResourceUri::ResourceUri(const ResourceUri& other524) {
+ resourceType = other524.resourceType;
+ uri = other524.uri;
+ __isset = other524.__isset;
}
-ResourceUri& ResourceUri::operator=(const ResourceUri& other495) {
- resourceType = other495.resourceType;
- uri = other495.uri;
- __isset = other495.__isset;
+ResourceUri& ResourceUri::operator=(const ResourceUri& other525) {
+ resourceType = other525.resourceType;
+ uri = other525.uri;
+ __isset = other525.__isset;
return *this;
}
void ResourceUri::printTo(std::ostream& out) const {
@@ -11415,9 +11912,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast496;
- xfer += iprot->readI32(ecast496);
- this->ownerType = (PrincipalType::type)ecast496;
+ int32_t ecast526;
+ xfer += iprot->readI32(ecast526);
+ this->ownerType = (PrincipalType::type)ecast526;
this->__isset.ownerType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11433,9 +11930,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 7:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast497;
- xfer += iprot->readI32(ecast497);
- this->functionType = (FunctionType::type)ecast497;
+ int32_t ecast527;
+ xfer += iprot->readI32(ecast527);
+ this->functionType = (FunctionType::type)ecast527;
this->__isset.functionType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11445,14 +11942,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->resourceUris.clear();
- uint32_t _size498;
- ::apache::thrift::protocol::TType _etype501;
- xfer += iprot->readListBegin(_etype501, _size498);
- this->resourceUris.resize(_size498);
- uint32_t _i502;
- for (_i502 = 0; _i502 < _size498; ++_i502)
+ uint32_t _size528;
+ ::apache::thrift::protocol::TType _etype531;
+ xfer += iprot->readListBegin(_etype531, _size528);
+ this->resourceUris.resize(_size528);
+ uint32_t _i532;
+ for (_i532 = 0; _i532 < _size528; ++_i532)
{
- xfer += this->resourceUris[_i502].read(iprot);
+ xfer += this->resourceUris[_i532].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11509,10 +12006,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 _iter503;
- for (_iter503 = this->resourceUris.begin(); _iter503 != this->resourceUris.end(); ++_iter503)
+ std::vector<ResourceUri> ::const_iterator _iter533;
+ for (_iter533 = this->resourceUris.begin(); _iter533 != this->resourceUris.end(); ++_iter533)
{
- xfer += (*_iter503).write(oprot);
+ xfer += (*_iter533).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11536,27 +12033,27 @@ void swap(Function &a, Function &b) {
swap(a.__isset, b.__isset);
}
-Function::Function(const Function& other504) {
- functionName = other504.functionName;
- dbName = other504.dbName;
- className = other504.className;
- ownerName = other504.ownerName;
- ownerType = other504.ownerType;
- createTime = other504.createTime;
- functionType = other504.functionType;
- resourceUris = other504.resourceUris;
- __isset = other504.__isset;
-}
-Function& Function::operator=(const Function& other505) {
- functionName = other505.functionName;
- dbName = other505.dbName;
- className = other505.className;
- ownerName = other505.ownerName;
- ownerType = other505.ownerType;
- createTime = other505.createTime;
- functionType = other505.functionType;
- resourceUris = other505.resourceUris;
- __isset = other505.__isset;
+Function::Function(const Function& other534) {
+ functionName = other534.functionName;
+ dbName = other534.dbName;
+ className = other534.className;
+ ownerName = other534.ownerName;
+ ownerType = other534.ownerType;
+ createTime = other534.createTime;
+ functionType = other534.functionType;
+ resourceUris = other534.resourceUris;
+ __isset = other534.__isset;
+}
+Function& Function::operator=(const Function& other535) {
+ functionName = other535.functionName;
+ dbName = other535.dbName;
+ className = other535.className;
+ ownerName = other535.ownerName;
+ ownerType = other535.ownerType;
+ createTime = other535.createTime;
+ functionType = other535.functionType;
+ resourceUris = other535.resourceUris;
+ __isset = other535.__isset;
return *this;
}
void Function::printTo(std::ostream& out) const {
@@ -11654,9 +12151,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast506;
- xfer += iprot->readI32(ecast506);
- this->state = (TxnState::type)ecast506;
+ int32_t ecast536;
+ xfer += iprot->readI32(ecast536);
+ this->state = (TxnState::type)ecast536;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -11803,29 +12300,29 @@ void swap(TxnInfo &a, TxnInfo &b) {
swap(a.__isset, b.__isset);
}
-TxnInfo::TxnInfo(const TxnInfo& other507) {
- id = other507.id;
- state = other507.state;
- user = other507.user;
- hostname = other507.hostname;
- agentInfo = other507.agentInfo;
- heartbeatCount = other507.heartbeatCount;
- metaInfo = other507.metaInfo;
- startedTime = other507.startedTime;
- lastHeartbeatTime = other507.lastHeartbeatTime;
- __isset = other507.__isset;
-}
-TxnInfo& TxnInfo::operator=(const TxnInfo& other508) {
- id = other508.id;
- state = other508.state;
- user = other508.user;
- hostname = other508.hostname;
- agentInfo = other508.agentInfo;
- heartbeatCount = other508.heartbeatCount;
- metaInfo = other508.metaInfo;
- startedTime = other508.startedTime;
- lastHeartbeatTime = other508.lastHeartbeatTime;
- __isset = other508.__isset;
+TxnInfo::TxnInfo(const TxnInfo& other537) {
+ id = other537.id;
+ state = other537.state;
+ user = other537.user;
+ hostname = other537.hostname;
+ agentInfo = other537.agentInfo;
+ heartbeatCount = other537.heartbeatCount;
+ metaInfo = other537.metaInfo;
+ startedTime = other537.startedTime;
+ lastHeartbeatTime = other537.lastHeartbeatTime;
+ __isset = other537.__isset;
+}
+TxnInfo& TxnInfo::operator=(const TxnInfo& other538) {
+ id = other538.id;
+ state = other538.state;
+ user = other538.user;
+ hostname = other538.hostname;
+ agentInfo = other538.agentInfo;
+ heartbeatCount = other538.heartbeatCount;
+ metaInfo = other538.metaInfo;
+ startedTime = other538.startedTime;
+ lastHeartbeatTime = other538.lastHeartbeatTime;
+ __isset = other538.__isset;
return *this;
}
void TxnInfo::printTo(std::ostream& out) const {
@@ -11891,14 +12388,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->open_txns.clear();
- uint32_t _size509;
- ::apache::thrift::protocol::TType _etype512;
- xfer += iprot->readListBegin(_etype512, _size509);
- this->open_txns.resize(_size509);
- uint32_t _i513;
- for (_i513 = 0; _i513 < _size509; ++_i513)
+ uint32_t _size539;
+ ::apache::thrift::protocol::TType _etype542;
+ xfer += iprot->readListBegin(_etype542, _size539);
+ this->open_txns.resize(_size539);
+ uint32_t _i543;
+ for (_i543 = 0; _i543 < _size539; ++_i543)
{
- xfer += this->open_txns[_i513].read(iprot);
+ xfer += this->open_txns[_i543].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11935,10 +12432,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 _iter514;
- for (_iter514 = this->open_txns.begin(); _iter514 != this->open_txns.end(); ++_iter514)
+ std::vector<TxnInfo> ::const_iterator _iter544;
+ for (_iter544 = this->open_txns.begin(); _iter544 != this->open_txns.end(); ++_iter544)
{
- xfer += (*_iter514).write(oprot);
+ xfer += (*_iter544).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11955,13 +12452,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) {
swap(a.open_txns, b.open_txns);
}
-GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other515) {
- txn_high_water_mark = other515.txn_high_water_mark;
- open_txns = other515.open_txns;
+GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other545) {
+ txn_high_water_mark = other545.txn_high_water_mark;
+ open_txns = other545.open_txns;
}
-GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other516) {
- txn_high_water_mark = other516.txn_high_water_mark;
- open_txns = other516.open_txns;
+GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other546) {
+ txn_high_water_mark = other546.txn_high_water_mark;
+ open_txns = other546.open_txns;
return *this;
}
void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const {
@@ -12025,15 +12522,15 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->open_txns.clear();
- uint32_t _size517;
- ::apache::thrift::protocol::TType _etype520;
- xfer += iprot->readSetBegin(_etype520, _size517);
- uint32_t _i521;
- for (_i521 = 0; _i521 < _size517; ++_i521)
+ uint32_t _size547;
+ ::apache::thrift::protocol::TType _etype550;
+ xfer += iprot->readSetBegin(_etype550, _size547);
+ uint32_t _i551;
+ for (_i551 = 0; _i551 < _size547; ++_i551)
{
- int64_t _elem522;
- xfer += iprot->readI64(_elem522);
- this->open_txns.insert(_elem522);
+ int64_t _elem552;
+ xfer += iprot->readI64(_elem552);
+ this->open_txns.insert(_elem552);
}
xfer += iprot->readSetEnd();
}
@@ -12078,10 +12575,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size()));
- std::set<int64_t> ::const_iterator _iter523;
- for (_iter523 = this->open_txns.begin(); _iter523 != this->open_txns.end(); ++_iter523)
+ std::set<int64_t> ::const_iterator _iter553;
+ for (_iter553 = this->open_txns.begin(); _iter553 != this->open_txns.end(); ++_iter553)
{
- xfer += oprot->writeI64((*_iter523));
+ xfer += oprot->writeI64((*_iter553));
}
xfer += oprot->writeSetEnd();
}
@@ -12105,17 +12602,17 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) {
swap(a.__isset, b.__isset);
}
-GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other524) {
- txn_high_water_mark = other524.txn_high_water_mark;
- open_txns = other524.open_txns;
- min_open_txn = other524.min_open_txn;
- __isset = other524.__isset;
+GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other554) {
+ txn_high_water_mark = other554.txn_high_water_mark;
+ open_txns = other554.open_txns;
+ min_open_txn = other554.min_open_txn;
+ __isset = other554.__isset;
}
-GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other525) {
- txn_high_water_mark = other525.txn_high_water_mark;
- open_txns = other525.open_txns;
- min_open_txn = other525.min_open_txn;
- __isset = other525.__isset;
+GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other555) {
+ txn_high_water_mark = other555.txn_high_water_mark;
+ open_txns = other555.open_txns;
+ min_open_txn = other555.min_open_txn;
+ __isset = other555.__isset;
return *this;
}
void GetOpenTxnsResponse::printTo(std::ostream& out) const {
@@ -12259,19 +12756,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) {
swap(a.__isset, b.__isset);
}
-OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other526) {
- num_txns = other526.num_txns;
- user = other526.user;
- hostname = other526.hostname;
- agentInfo = other526.agentInfo;
- __isset = other526.__isset;
+OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other556) {
+ num_txns = other556.num_txns;
+ user = other556.user;
+ hostname = other556.hostname;
+ agentInfo = other556.agentInfo;
+ __isset = other556.__isset;
}
-OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other527) {
- num_txns = other527.num_txns;
- user = other527.user;
- hostname = other527.hostname;
- agentInfo = other527.agentInfo;
- __isset = other527.__isset;
+OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other557) {
+ num_txns = other557.num_txns;
+ user = other557.user;
+ hostname = other557.hostname;
+ agentInfo = other557.agentInfo;
+ __isset = other557.__isset;
return *this;
}
void OpenTxnRequest::printTo(std::ostream& out) const {
@@ -12319,14 +12816,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- uint32_t _size528;
- ::apache::thrift::protocol::TType _etype531;
- xfer += iprot->readListBegin(_etype531, _size528);
- this->txn_ids.resize(_size528);
- uint32_t _i532;
- for (_i532 = 0; _i532 < _size528; ++_i532)
+ uint32_t _size558;
+ ::apache::thrift::protocol::TType _etype561;
+ xfer += iprot->readListBegin(_etype561, _size558);
+ this->txn_ids.resize(_size558);
+ uint32_t _i562;
+ for (_i562 = 0; _i562 < _size558; ++_i562)
{
- xfer += iprot->readI64(this->txn_ids[_i532]);
+ xfer += iprot->readI64(this->txn_ids[_i562]);
}
xfer += iprot->readListEnd();
}
@@ -12357,10 +12854,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 _iter533;
- for (_iter533 = this->txn_ids.begin(); _iter533 != this->txn_ids.end(); ++_iter533)
+ std::vector<int64_t> ::const_iterator _iter563;
+ for (_iter563 = this->txn_ids.begin(); _iter563 != this->txn_ids.end(); ++_iter563)
{
- xfer += oprot->writeI64((*_iter533));
+ xfer += oprot->writeI64((*_iter563));
}
xfer += oprot->writeListEnd();
}
@@ -12376,11 +12873,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) {
swap(a.txn_ids, b.txn_ids);
}
-OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other534) {
- txn_ids = other534.txn_ids;
+OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other564) {
+ txn_ids = other564.txn_ids;
}
-OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other535) {
- txn_ids = other535.txn_ids;
+OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other565) {
+ txn_ids = other565.txn_ids;
return *this;
}
void OpenTxnsResponse::printTo(std::ostream& out) const {
@@ -12462,11 +12959,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other536) {
- txnid = other536.txnid;
+AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other566) {
+ txnid = other566.txnid;
}
-AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other537) {
- txnid = other537.txnid;
+AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other567) {
+ txnid = other567.txnid;
return *this;
}
void AbortTxnRequest::printTo(std::ostream& out) const {
@@ -12511,14 +13008,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- uint32_t _size538;
- ::apache::thrift::protocol::TType _etype541;
- xfer += iprot->readListBegin(_etype541, _size538);
- this->txn_ids.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->txn_ids.resize(_size568);
+ uint32_t _i572;
+ for (_i572 = 0; _i572 < _size568; ++_i572)
{
- xfer += iprot->readI64(this->txn_ids[_i542]);
+ xfer += iprot->readI64(this->txn_ids[_i572]);
}
xfer += iprot->readListEnd();
}
@@ -12549,10 +13046,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 _iter543;
- for (_iter543 = this->txn_ids.begin(); _iter543 != this->txn_ids.end(); ++_iter543)
+ std::vector<int64_t> ::const_iterator _iter573;
+ for (_iter573 = this->txn_ids.begin(); _iter573 != this->txn_ids.end(); ++_iter573)
{
- xfer += oprot->writeI64((*_iter543));
+ xfer += oprot->writeI64((*_iter573));
}
xfer += oprot->writeListEnd();
}
@@ -12568,11 +13065,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) {
swap(a.txn_ids, b.txn_ids);
}
-AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other544) {
- txn_ids = other544.txn_ids;
+AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other574) {
+ txn_ids = other574.txn_ids;
}
-AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other545) {
- txn_ids = other545.txn_ids;
+AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other575) {
+ txn_ids = other575.txn_ids;
return *this;
}
void AbortTxnsRequest::printTo(std::ostream& out) const {
@@ -12654,11 +13151,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other546) {
- txnid = other546.txnid;
+CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other576) {
+ txnid = other576.txnid;
}
-CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other547) {
- txnid = other547.txnid;
+CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other577) {
+ txnid = other577.txnid;
return *this;
}
void CommitTxnRequest::printTo(std::ostream& out) const {
@@ -12736,9 +13233,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast548;
- xfer += iprot->readI32(ecast548);
- this->type = (LockType::type)ecast548;
+ int32_t ecast578;
+ xfer += iprot->readI32(ecast578);
+ this->type = (LockType::type)ecast578;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -12746,9 +13243,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast549;
- xfer += iprot->readI32(ecast549);
- this->level = (LockLevel::type)ecast549;
+ int32_t ecast579;
+ xfer += iprot->readI32(ecast579);
+ this->level = (LockLevel::type)ecast579;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -12780,9 +13277,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast550;
- xfer += iprot->readI32(ecast550);
- this->operationType = (DataOperationType::type)ecast550;
+ int32_t ecast580;
+ xfer += iprot->readI32(ecast580);
+ this->operationType = (DataOperationType::type)ecast580;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -12882,27 +13379,27 @@ void swap(LockComponent &a, LockComponent &b) {
swap(a.__isset, b.__isset);
}
-LockComponent::LockComponent(const LockComponent& other551) {
- type = other551.type;
- level = other551.level;
- dbname = other551.dbname;
- tablename = other551.tablename;
- partitionname = other551.partitionname;
- operationType = other551.operationType;
- isAcid = other551.isAcid;
- isDynamicPartitionWrite = other551.isDynamicPartitionWrite;
- __isset = other551.__isset;
-}
-LockComponent& LockComponent::operator=(const LockComponent& other552) {
- type = other552.type;
- level = other552.level;
- dbname = other552.dbname;
- tablename = other552.tablename;
- partitionname = other552.partitionname;
- operationType = other552.operationType;
- isAcid = other552.isAcid;
- isDynamicPartitionWrite = other552.isDynamicPartitionWrite;
- __isset = other552.__isset;
+LockComponent::LockComponent(const LockComponent& other581) {
+ type = other581.type;
+ level = other581.level;
+ dbname = other581.dbname;
+ tablename = other581.tablename;
+ partitionname = other581.partitionname;
+ operationType = other581.operationType;
+ isAcid = other581.isAcid;
+ isDynamicPartitionWrite = other581.isDynamicPartitionWrite;
+ __isset = other581.__isset;
+}
+LockComponent& LockComponent::operator=(const LockComponent& other582) {
+ type = other582.type;
+ level = other582.level;
+ dbname = other582.dbname;
+ tablename = other582.tablename;
+ partitionname = other582.partitionname;
+ operationType = other582.operationType;
+ isAcid = other582.isAcid;
+ isDynamicPartitionWrite = other582.isDynamicPartitionWrite;
+ __isset = other582.__isset;
return *this;
}
void LockComponent::printTo(std::ostream& out) const {
@@ -12974,14 +13471,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- uint32_t _size553;
- ::apache::thrift::protocol::TType _etype556;
- xfer += iprot->readListBegin(_etype556, _size553);
- this->component.resize(_size553);
- uint32_t _i557;
- for (_i557 = 0; _i557 < _size553; ++_i557)
+ uint32_t _size583;
+ ::apache::thrift::protocol::TType _etype586;
+ xfer += iprot->readListBegin(_etype586, _size583);
+ this->component.resize(_size583);
+ uint32_t _i587;
+ for (_i587 = 0; _i587 < _size583; ++_i587)
{
- xfer += this->component[_i557].read(iprot);
+ xfer += this->component[_i587].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -13048,10 +13545,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 _iter558;
- for (_iter558 = this->component.begin(); _iter558 != this->component.end(); ++_iter558)
+ std::vector<LockComponent> ::const_iterator _iter588;
+ for (_iter588 = this->component.begin(); _iter588 != this->component.end(); ++_iter588)
{
- xfer += (*_iter558).write(oprot);
+ xfer += (*_iter588).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13090,21 +13587,21 @@ void swap(LockRequest &a, LockRequest &b) {
swap(a.__isset, b.__isset);
}
-LockRequest::LockRequest(const LockRequest& other559) {
- component = other559.component;
- txnid = other559.txnid;
- user = other559.user;
- hostname = other559.hostname;
- agentInfo = other559.agentInfo;
- __isset = other559.__isset;
-}
-LockRequest& LockRequest::operator=(const LockRequest& other560) {
- component = other560.component;
- txnid = other560.txnid;
- user = other560.user;
- hostname = other560.hostname;
- agentInfo = other560.agentInfo;
- __isset = other560.__isset;
+LockRequest::LockRequest(const LockRequest& other589) {
+ component = other589.component;
+ txnid = other589.txnid;
+ user = other589.user;
+ hostname = other589.hostname;
+ agentInfo = other589.agentInfo;
+ __isset = other589.__isset;
+}
+LockRequest& LockRequest::operator=(const LockRequest& other590) {
+ component = other590.component;
+ txnid = other590.txnid;
+ user = other590.user;
+ hostname = other590.hostname;
+ agentInfo = other590.agentInfo;
+ __isset = other590.__isset;
return *this;
}
void LockRequest::printTo(std::ostream& out) const {
@@ -13164,9 +13661,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast561;
- xfer += iprot->readI32(ecast561);
- this->state = (LockState::type)ecast561;
+ int32_t ecast591;
+ xfer += iprot->readI32(ecast591);
+ this->state = (LockState::type)ecast591;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -13212,13 +13709,13 @@ void swap(LockResponse &a, LockResponse &b) {
swap(a.state, b.state);
}
-LockResponse::LockResponse(const LockResponse& other562) {
- lockid = other562.lockid;
- state = other562.state;
+LockResponse::LockResponse(const LockResponse& other592) {
+ lockid = other592.lockid;
+ state = other592.state;
}
-LockResponse& LockResponse::operator=(const LockResponse& other563) {
- lockid = other563.lockid;
- state = other563.state;
+LockResponse& LockResponse::operator=(const LockResponse& other593) {
+ lockid = other593.lockid;
+ state = other593.state;
return *this;
}
void LockResponse::printTo(std::ostream& out) const {
@@ -13340,17 +13837,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) {
swap(a.__isset, b.__isset);
}
-CheckLockRequest::CheckLockRequest(const CheckLockRequest& other564) {
- lockid = other564.lockid;
- txnid = other564.txnid;
- elapsed_ms = other564.elapsed_ms;
- __isset = other564.__isset;
+CheckLockRequest::CheckLockRequest(const CheckLockRequest& other594) {
+ lockid = other594.lockid;
+ txnid = other594.txnid;
+ elapsed_ms = other594.elapsed_ms;
+ __isset = other594.__isset;
}
-CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other565) {
- lockid = other565.lockid;
- txnid = other565.txnid;
- elapsed_ms = other565.elapsed_ms;
- __isset = other565.__isset;
+CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other595) {
+ lockid = other595.lockid;
+ txnid = other595.txnid;
+ elapsed_ms = other595.elapsed_ms;
+ __isset = other595.__isset;
return *this;
}
void CheckLockRequest::printTo(std::ostream& out) const {
@@ -13434,11 +13931,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) {
swap(a.lockid, b.lockid);
}
-UnlockRequest::UnlockRequest(const UnlockRequest& other566) {
- lockid = other566.lockid;
+UnlockRequest::UnlockRequest(const UnlockRequest& other596) {
+ lockid = other596.lockid;
}
-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other567) {
- lockid = other567.lockid;
+UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other597) {
+ lockid = other597.lockid;
return *this;
}
void UnlockRequest::printTo(std::ostream& out) const {
@@ -13577,19 +14074,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other568) {
- dbname = other568.dbname;
- tablename = other568.tablename;
- partname = other568.partname;
- isExtended = other568.isExtended;
- __isset = other568.__isset;
+ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other598) {
+ dbname = other598.dbname;
+ tablename = other598.tablename;
+ partname = other598.partname;
+ isExtended = other598.isExtended;
+ __isset = other598.__isset;
}
-ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other569) {
- dbname = other569.dbname;
- tablename = other569.tablename;
- partname = other569.partname;
- isExtended = other569.isExtended;
- __isset = other569.__isset;
+ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other599) {
+ dbname = other599.dbname;
+ tablename = other599.tablename;
+ partname = other599.partname;
+ isExtended = other599.isExtended;
+ __isset = other599.__isset;
return *this;
}
void ShowLocksRequest::printTo(std::ostream& out) const {
@@ -13742,9 +14239,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast570;
- xfer += iprot->readI32(ecast570);
- this->state = (LockState::type)ecast570;
+ int32_t ecast600;
+ xfer += iprot->readI32(ecast600);
+ this->state = (LockState::type)ecast600;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -13752,9 +14249,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast571;
- xfer += iprot->readI32(ecast571);
- this->type = (LockType::type)ecast571;
+ int32_t ecast601;
+ xfer += iprot->readI32(ecast601);
+ this->type = (LockType::type)ecast601;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -13970,43 +14467,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other572) {
- lockid = other572.lockid;
- dbname = other572.dbname;
- tablename = other572.tablename;
- partname = other572.partname;
- state = other572.state;
- type = other572.type;
- txnid = other572.txnid;
- lastheartbeat = other572.lastheartbeat;
- acquiredat = other572.acquiredat;
- user = other572.user;
- hostname = other572.hostname;
- heartbeatCount = other572.heartbeatCount;
- agentInfo = other572.agentInfo;
- blockedByExtId = other572.blockedByExtId;
- blockedByIntId = other572.blockedByIntId;
- lockIdInternal = other572.lockIdInternal;
- __isset = other572.__isset;
-}
-ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other573) {
- lockid = other573.lockid;
- dbname = other573.dbname;
- tablename = other573.tablename;
- partname = other573.partname;
- state = other573.state;
- type = other573.type;
- txnid = other573.txnid;
- lastheartbeat = other573.lastheartbeat;
- acquiredat = other573.acquiredat;
- user = other573.user;
- hostname = other573.hostname;
- heartbeatCount = other573.heartbeatCount;
- agentInfo = other573.agentInfo;
- blockedByExtId = other573.blockedByExtId;
- blockedByIntId = other573.blockedByIntId;
- lockIdInternal = other573.lockIdInternal;
- __isset = other573.__isset;
+ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other602) {
+ lockid = other602.lockid;
+ dbname = other602.dbname;
+ tablename = other602.tablename;
+ partname = other602.partname;
+ state = other602.state;
+ type = other602.type;
+ txnid = other602.txnid;
+ lastheartbeat = other602.lastheartbeat;
+ acquiredat = other602.acquiredat;
+ user = other602.user;
+ hostname = other602.hostname;
+ heartbeatCount = other602.heartbeatCount;
+ agentInfo = other602.agentInfo;
+ blockedByExtId = other602.blockedByExtId;
+ blockedByIntId = other602.blockedByIntId;
+ lockIdInternal = other602.lockIdInternal;
+ __isset = other602.__isset;
+}
+ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other603) {
+ lockid = other603.lockid;
+ dbname = other603.dbname;
+ tablename = other603.tablename;
+ partname = other603.partname;
+ state = other603.state;
+ type = other603.type;
+ txnid = other603.txnid;
+ lastheartbeat = other603.lastheartbeat;
+ acquiredat = other603.acquiredat;
+ user = other603.user;
+ hostname = other603.hostname;
+ heartbeatCount = other603.heartbeatCount;
+ agentInfo = other603.agentInfo;
+ blockedByExtId = other603.blockedByExtId;
+ blockedByIntId = other603.blockedByIntId;
+ lockIdInternal = other603.lockIdInternal;
+ __isset = other603.__isset;
return *this;
}
void ShowLocksResponseElement::printTo(std::ostream& out) const {
@@ -14065,14 +14562,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- uint32_t _size574;
- ::apache::thrift::protocol::TType _etype577;
- xfer += iprot->readListBegin(_etype577, _size574);
- this->locks.resize(_size574);
- uint32_t _i578;
- for (_i578 = 0; _i578 < _size574; ++_i578)
+ uint32_t _size604;
+ ::apache::thrift::protocol::TType _etype607;
+ xfer += iprot->readListBegin(_etype607, _size604);
+ this->locks.resize(_size604);
+ uint32_t _i608;
+ for (_i608 = 0; _i608 < _size604; ++_i608)
{
- xfer += this->locks[_i578].read(iprot);
+ xfer += this->locks[_i608].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -14101,10 +14598,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 _iter579;
- for (_iter579 = this->locks.begin(); _iter579 != this->locks.end(); ++_iter579)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter609;
+ for (_iter609 = this->locks.begin(); _iter609 != this->locks.end(); ++_iter609)
{
- xfer += (*_iter579).write(oprot);
+ xfer += (*_iter609).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -14121,13 +14618,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other580) {
- locks = other580.locks;
- __isset = other580.__isset;
+ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other610) {
+ locks = other610.locks;
+ __isset = other610.__isset;
}
-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other581) {
- locks = other581.locks;
- __isset = other581.__isset;
+ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other611) {
+ locks = other611.locks;
+ __isset = other611.__isset;
return *this;
}
void ShowLocksResponse::printTo(std::ostream& out) const {
@@ -14228,15 +14725,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) {
swap(a.__isset, b.__isset);
}
-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other582) {
- lockid = other582.lockid;
- txnid = other582.txnid;
- __isset = other582.__isset;
+HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other612) {
+ lockid = other612.lockid;
+ txnid = other612.txnid;
+ __isset = other612.__isset;
}
-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other583) {
- lockid = other583.lockid;
- txnid = other583.txnid;
- __isset = other583.__isset;
+HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other613) {
+ lockid = other613.lockid;
+ txnid = other613.txnid;
+ __isset = other613.__isset;
return *this;
}
void HeartbeatRequest::printTo(std::ostream& out) const {
@@ -14339,13 +14836,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) {
swap(a.max, b.max);
}
-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other584) {
- min = other584.min;
- max = other584.max;
+HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other614) {
+ min = other614.min;
+ max = other614.max;
}
-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other585) {
- min = other585.min;
- max = other585.max;
+HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other615) {
+ min = other615.min;
+ max = other615.max;
return *this;
}
void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const {
@@ -14396,15 +14893,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size586;
- ::apache::thrift::protocol::TType _etype589;
- xfer += iprot->readSetBegin(_etype589, _size586);
- uint32_t _i590;
- for (_i590 = 0; _i590 < _size586; ++_i590)
+ uint32_t _size616;
+ ::apache::thrift::protocol::TType _etype619;
+ xfer += iprot->readSetBegin(_etype619, _size616);
+ uint32_t _i620;
+ for (_i620 = 0; _i620 < _size616; ++_i620)
{
- int64_t _elem591;
- xfer += iprot->readI64(_elem591);
- this->aborted.insert(_elem591);
+ int64_t _elem621;
+ xfer += iprot->readI64(_elem621);
+ this->aborted.insert(_elem621);
}
xfer += iprot->readSetEnd();
}
@@ -14417,15 +14914,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size592;
- ::apache::thrift::protocol::TType _etype595;
- xfer += iprot->readSetBegin(_etype595, _size592);
- uint32_t _i596;
- for (_i596 = 0; _i596 < _size592; ++_i596)
+ uint32_t _size622;
+ ::apache::thrift::protocol::TType _etype625;
+ xfer += iprot->readSetBegin(_etype625, _size622);
+ uint32_t _i626;
+ for (_i626 = 0; _i626 < _size622; ++_i626)
{
- int64_t _elem597;
- xfer += iprot->readI64(_elem597);
- this->nosuch.insert(_elem597);
+ int64_t _elem627;
+ xfer += iprot->readI64(_elem627);
+ this->nosuch.insert(_elem627);
}
xfer += iprot->readSetEnd();
}
@@ -14458,10 +14955,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 _iter598;
- for (_iter598 = this->aborted.begin(); _iter598 != this->aborted.end(); ++_iter598)
+ std::set<int64_t> ::const_iterator _iter628;
+ for (_iter628 = this->aborted.begin(); _iter628 != this->aborted.end(); ++_iter628)
{
- xfer += oprot->writeI64((*_iter598));
+ xfer += oprot->writeI64((*_iter628));
}
xfer += oprot->writeSetEnd();
}
@@ -14470,10 +14967,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 _iter599;
- for (_iter599 = this->nosuch.begin(); _iter599 != this->nosuch.end(); ++_iter599)
+ std::set<int64_t> ::const_iterator _iter629;
+ for (_iter629 = this->nosuch.begin(); _iter629 != this->nosuch.end(); ++_iter629)
{
- xfer += oprot->writeI64((*_iter599));
+ xfer += oprot->writeI64((*_iter629));
}
xfer += oprot->writeSetEnd();
}
@@ -14490,13 +14987,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) {
swap(a.nosuch, b.nosuch);
}
-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other600) {
- aborted = other600.aborted;
- nosuch = other600.nosuch;
+HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other630) {
+ aborted = other630.aborted;
+ nosuch = other630.nosuch;
}
-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other601) {
- aborted = other601.aborted;
- nosuch = other601.nosuch;
+HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other631) {
+ aborted = other631.aborted;
+ nosuch = other631.nosuch;
return *this;
}
void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const {
@@ -14589,9 +15086,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast602;
- xfer += iprot->readI32(ecast602);
- this->type = (CompactionType::type)ecast602;
+ int32_t ecast632;
+ xfer += iprot->readI32(ecast632);
+ this->type = (CompactionType::type)ecast632;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -14609,17 +15106,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size603;
- ::apache::thrift::protocol::TType _ktype604;
- ::apache::thrift::protocol::TType _vtype605;
- xfer += iprot->readMapBegin(_ktype604, _vtype605, _size603);
- uint32_t _i607;
- for (_i607 = 0; _i607 < _size603; ++_i607)
+ uint32_t _size633;
+ ::apache::thrift::protocol::TType _ktype634;
+ ::apache::thrift::protocol::TType _vtype635;
+ xfer += iprot->readMapBegin(_ktype634, _vtype635, _size633);
+ uint32_t _i637;
+ for (_i637 = 0; _i637 < _size633; ++_i637)
{
- std::string _key608;
- xfer += iprot->readString(_key608);
- std::string& _val609 = this->properties[_key608];
- xfer += iprot->readString(_val609);
+ std::string _key638;
+ xfer += iprot->readString(_key638);
+ std::string& _val639 = this->properties[_key638];
+ xfer += iprot->readString(_val639);
}
xfer += iprot->readMapEnd();
}
@@ -14677,11 +15174,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 _iter610;
- for (_iter610 = this->properties.begin(); _iter610 != this->properties.end(); ++_iter610)
+ std::map<std::string, std::string> ::const_iterator _iter640;
+ for (_iter640 = this->properties.begin(); _iter640 != this->properties.end(); ++_iter640)
{
- xfer += oprot->writeString(_iter610->first);
- xfer += oprot->writeString(_iter610->second);
+ xfer += oprot->writeString(_iter640->first);
+ xfer += oprot->writeString(_iter640->second);
}
xfer += oprot->writeMapEnd();
}
@@ -14703,23 +15200,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) {
swap(a.__isset, b.__isset);
}
-CompactionRequest::CompactionRequest(const CompactionRequest& other611) {
- dbname = other611.dbname;
- tablename = other611.tablename;
- partitionname = other611.partitionname;
- type = other611.type;
- runas = other611.runas;
- properties = other611.properties;
- __isset = other611.__isset;
-}
-CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other612) {
- dbname = other612.dbname;
- tablename = other612.tablename;
- partitionname = other612.partitionname;
- type = other612.type;
- runas = other612.runas;
- properties = other612.properties;
- __isset = other612.__isset;
+CompactionRequest::CompactionRequest(const CompactionRequest& other641) {
+ dbname = other641.dbname;
+ tablename = other641.tablename;
+ partitionname = other641.partitionname;
+ type = other641.type;
+ runas = other641.runas;
+ properties = other641.properties;
+ __isset = other641.__isset;
+}
+CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other642) {
+ dbname = other642.dbname;
+ tablename = other642.tablename;
+ partitionname = other642.partitionname;
+ type = other642.type;
+ runas = other642.runas;
+ properties = other642.properties;
+ __isset = other642.__isset;
return *this;
}
void CompactionRequest::printTo(std::ostream& out) const {
@@ -14846,15 +15343,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) {
swap(a.accepted, b.accepted);
}
-CompactionResponse::CompactionResponse(const CompactionResponse& other613) {
- id = other613.id;
- state = other613.state;
- accepted = other613.accepted;
+CompactionResponse::CompactionResponse(const CompactionResponse& other643) {
+ id = other643.id;
+ state = other643.state;
+ accepted = other643.accepted;
}
-CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other614) {
- id = other614.id;
- state = other614.state;
- accepted = other614.accepted;
+CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other644) {
+ id = other644.id;
+ state = other644.state;
+ accepted = other644.accepted;
return *this;
}
void CompactionResponse::printTo(std::ostream& out) const {
@@ -14915,11 +15412,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) {
(void) b;
}
-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other615) {
- (void) other615;
+ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other645) {
+ (void) other645;
}
-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other616) {
- (void) other616;
+ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other646) {
+ (void) other646;
return *this;
}
void ShowCompactRequest::printTo(std::ostream& out) const {
@@ -15045,9 +15542,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol*
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast617;
- xfer += iprot->readI32(ecast617);
- this->type = (CompactionType::type)ecast617;
+ int32_t ecast647;
+ xfer += iprot->readI32(ecast647);
+ this->type = (CompactionType::type)ecast647;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -15234,37 +15731,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other618) {
- dbname = other618.dbname;
- tablename = other618.tablename;
- partitionname = other618.partitionname;
- type = other618.type;
- state = other618.state;
- workerid = other618.workerid;
- start = other618.start;
- runAs = other618.runAs;
- hightestTxnId = other618.hightestTxnId;
- metaInfo = other618.metaInfo;
- endTime = other618.endTime;
- hadoopJobId = other618.hadoopJobId;
- id = other618.id;
- __isset = other618.__isset;
-}
-ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other619) {
- dbname = other619.dbname;
- tablename = other619.tablename;
- partitionname = other619.partitionname;
- type = other619.type;
- state = other619.state;
- workerid = other619.workerid;
- start = other619.start;
- runAs = other619.runAs;
- hightestTxnId = other619.hightestTxnId;
- metaInfo = other619.metaInfo;
- endTime = other619.endTime;
- hadoopJobId = other619.hadoopJobId;
- id = other619.id;
- __isset = other619.__isset;
+ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other648) {
+ dbname = other648.dbname;
+ tablename = other648.tablename;
+ partitionname = other648.partitionname;
+ type = other648.type;
+ state = other648.state;
+ workerid = other648.workerid;
+ start = other648.start;
+ runAs = other648.runAs;
+ hightestTxnId = other648.hightestTxnId;
+ metaInfo = other648.metaInfo;
+ endTime = other648.endTime;
+ hadoopJobId = other648.hadoopJobId;
+ id = other648.id;
+ __isset = other648.__isset;
+}
+ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other649) {
+ dbname = other649.dbname;
+ tablename = other649.tablename;
+ partitionname = other649.partitionname;
+ type = other649.type;
+ state = other649.state;
+ workerid = other649.workerid;
+ start = other649.start;
+ runAs = other649.runAs;
+ hightestTxnId = other649.hightestTxnId;
+ metaInfo = other649.metaInfo;
+ endTime = other649.endTime;
+ hadoopJobId = other649.hadoopJobId;
+ id = other649.id;
+ __isset = other649.__isset;
return *this;
}
void ShowCompactResponseElement::printTo(std::ostream& out) const {
@@ -15321,14 +15818,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- uint32_t _size620;
- ::apache::thrift::protocol::TType _etype623;
- xfer += iprot->readListBegin(_etype623, _size620);
- this->compacts.resize(_size620);
- uint32_t _i624;
- for (_i624 = 0; _i624 < _size620; ++_i624)
+ uint32_t _size650;
+ ::apache::thrift::protocol::TType _etype653;
+ xfer += iprot->readListBegin(_etype653, _size650);
+ this->compacts.resize(_size650);
+ uint32_t _i654;
+ for (_i654 = 0; _i654 < _size650; ++_i654)
{
- xfer += this->compacts[_i624].read(iprot);
+ xfer += this->compacts[_i654].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -15359,10 +15856,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 _iter625;
- for (_iter625 = this->compacts.begin(); _iter625 != this->compacts.end(); ++_iter625)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter655;
+ for (_iter655 = this->compacts.begin(); _iter655 != this->compacts.end(); ++_iter655)
{
- xfer += (*_iter625).write(oprot);
+ xfer += (*_iter655).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -15378,11 +15875,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) {
swap(a.compacts, b.compacts);
}
-ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other626) {
- compacts = other626.compacts;
+ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other656) {
+ compacts = other656.compacts;
}
-ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other627) {
- compacts = other627.compacts;
+ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other657) {
+ compacts = other657.compacts;
return *this;
}
void ShowCompactResponse::printTo(std::ostream& out) const {
@@ -15471,14 +15968,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionnames.clear();
- uint32_t _size628;
- ::apache::thrift::protocol::TType _etype631;
- xfer += iprot->readListBegin(_etype631, _size628);
- this->partitionnames.resize(_size628);
- uint32_t _i632;
- for (_i632 = 0; _i632 < _size628; ++_i632)
+ uint32_t _size658;
+ ::apache::thrift::protocol::TType _etype661;
+ xfer += iprot->readListBegin(_etype661, _size658);
+ this->partitionnames.resize(_size658);
+ uint32_t _i662;
+ for (_i662 = 0; _i662 < _size658; ++_i662)
{
- xfer += iprot->readString(this->partitionnames[_i632]);
+ xfer += iprot->readString(this->partitionnames[_i662]);
}
xfer += iprot->readListEnd();
}
@@ -15489,9 +15986,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast633;
- xfer += iprot->readI32(ecast633);
- this->operationType = (DataOperationType::type)ecast633;
+ int32_t ecast663;
+ xfer += iprot->readI32(ecast663);
+ this->operationType = (DataOperationType::type)ecast663;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -15537,10 +16034,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 _iter634;
- for (_iter634 = this->partitionnames.begin(); _iter634 != this->partitionnames.end(); ++_iter634)
+ std::vector<std::string> ::const_iterator _iter664;
+ for (_iter664 = this->partitionnames.begin(); _iter664 != this->partitionnames.end(); ++_iter664)
{
- xfer += oprot->writeString((*_iter634));
+ xfer += oprot->writeString((*_iter664));
}
xfer += oprot->writeListEnd();
}
@@ -15566,21 +16063,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) {
swap(a.__isset, b.__isset);
}
-AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other635) {
- txnid = other635.txnid;
- dbname = other635.dbname;
- tablename = other635.tablename;
- partitionnames = other635.partitionnames;
- operationType = other635.operationType;
- __isset = other635.__isset;
-}
-AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other636) {
- txnid = other636.txnid;
- dbname = other636.dbname;
- tablename = other636.tablename;
- partitionnames = other636.partitionnames;
- operationType = other636.operationType;
- __isset = other636.__isset;
+AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other665) {
+ txnid = other665.txnid;
+ dbname = other665.dbname;
+ tablename = other665.tablename;
+ partitionnames = other665.partitionnames;
+ operationType = other665.operationType;
+ __isset = other665.__isset;
+}
+AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other666) {
+ txnid = other666.txnid;
+ dbname = other666.dbname;
+ tablename = other666.tablename;
+ partitionnames = other666.partitionnames;
+ operationType = other666.operationType;
+ __isset = other666.__isset;
return *this;
}
void AddDynamicPartitions::printTo(std::ostream& out) const {
@@ -15686,15 +16183,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
swap(a.__isset, b.__isset);
}
-NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other637) {
- lastEvent = other637.lastEvent;
- maxEvents = other637.maxEvents;
- __isset = other637.__isset;
+NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other667) {
+ lastEvent = other667.lastEvent;
+ maxEvents = other667.maxEvents;
+ __isset = other667.__isset;
}
-NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other638) {
- lastEvent = other638.lastEvent;
- maxEvents = other638.maxEvents;
- __isset = other638.__isset;
+NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other668) {
+ lastEvent = other668.lastEvent;
+ maxEvents = other668.maxEvents;
+ __isset = other668.__isset;
return *this;
}
void NotificationEventRequest::printTo(std::ostream& out) const {
@@ -15895,25 +16392,25 @@ void swap(NotificationEvent &a, NotificationEvent &b) {
swap(a.__isset, b.__isset);
}
-NotificationEvent::NotificationEvent(const NotificationEvent& other639) {
- eventId = other639.eventId;
- eventTime = other639.eventTime;
- eventType = other639.eventType;
- dbName = other639.dbName;
- tableName = other639.tableName;
- message = other639.message;
- messageFormat = other639.messageFormat;
- __isset = other639.__isset;
-}
-NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other640) {
- eventId = other640.eventId;
- eventTime = other640.eventTime;
- eventType = other640.eventType;
- dbName = other640.dbName;
- tableName = other640.tableName;
- message = other640.message;
- messageFormat = other640.messageFormat;
- __isset = other640.__isset;
+NotificationEvent::NotificationEvent(const NotificationEvent& other669) {
+ eventId = other669.eventId;
+ eventTime = other669.eventTime;
+ eventType = other669.eventType;
+ dbName = other669.dbName;
+ tableName = other669.tableName;
+ message = other669.message;
+ messageFormat = other669.messageFormat;
+ __isset = other669.__isset;
+}
+NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other670) {
+ eventId = other670.eventId;
+ eventTime = other670.eventTime;
+ eventType = other670.eventType;
+ dbName = other670.dbName;
+ tableName = other670.tableName;
+ message = other670.message;
+ messageFormat = other670.messageFormat;
+ __isset = other670.__isset;
return *this;
}
void NotificationEvent::printTo(std::ostream& out) const {
@@ -15964,14 +16461,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->events.clear();
- uint32_t _size641;
- ::apache::thrift::protocol::TType _etype644;
- xfer += iprot->readListBegin(_etype644, _size641);
- this->events.resize(_size641);
- uint32_t _i645;
- for (_i645 = 0; _i645 < _size641; ++_i645)
+ uint32_t _size671;
+ ::apache::thrift::protocol::TType _etype674;
+ xfer += iprot->readListBegin(_etype674, _size671);
+ this->events.resize(_size671);
+ uint32_t _i675;
+ for (_i675 = 0; _i675 < _size671; ++_i675)
{
- xfer += this->events[_i645].read(iprot);
+ xfer += this->events[_i675].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -16002,10 +16499,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 _iter646;
- for (_iter646 = this->events.begin(); _iter646 != this->events.end(); ++_iter646)
+ std::vector<NotificationEvent> ::const_iterator _iter676;
+ for (_iter676 = this->events.begin(); _iter676 != this->events.end(); ++_iter676)
{
- xfer += (*_iter646).write(oprot);
+ xfer += (*_iter676).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -16021,11 +16518,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) {
swap(a.events, b.events);
}
-NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other647) {
- events = other647.events;
+NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other677) {
+ events = other677.events;
}
-NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other648) {
- events = other648.events;
+NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other678) {
+ events = other678.events;
return *this;
}
void NotificationEventResponse::printTo(std::ostream& out) const {
@@ -16107,11 +16604,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) {
swap(a.eventId, b.eventId);
}
-CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other649) {
- eventId = other649.eventId;
+CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other679) {
+ eventId = other679.eventId;
}
-CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other650) {
- eventId = other650.eventId;
+CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other680) {
+ eventId = other680.eventId;
return *this;
}
void CurrentNotificationEventId::printTo(std::ostream& out) const {
@@ -16161,14 +16658,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAdded.clear();
- uint32_t _size651;
- ::apache::thrift::protocol::TType _etype654;
- xfer += iprot->readListBegin(_etype654, _size651);
- this->filesAdded.resize(_size651);
- uint32_t _i655;
- for (_i655 = 0; _i655 < _size651; ++_i655)
+ uint32_t _size681;
+ ::apache::thrift::protocol::TType _etype684;
+ xfer += iprot->readListBegin(_etype684, _size681);
+ this->filesAdded.resize(_size681);
+ uint32_t _i685;
+ for (_i685 = 0; _i685 < _size681; ++_i685)
{
- xfer += iprot->readString(this->filesAdded[_i655]);
+ xfer += iprot->readString(this->filesAdded[_i685]);
}
xfer += iprot->readListEnd();
}
@@ -16181,14 +16678,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAddedChecksum.clear();
- uint32_t _size656;
- ::apache::thrift::protocol::TType _etype659;
- xfer += iprot->readListBegin(_etype659, _size656);
- this->filesAddedChecksum.resize(_size656);
- uint32_t _i660;
- for (_i660 = 0; _i660 < _size656; ++_i660)
+ uint32_t _size686;
+ ::apache::thrift::protocol::TType _etype689;
+ xfer += iprot->readListBegin(_etype689, _size686);
+ this->filesAddedChecksum.resize(_size686);
+ uint32_t _i690;
+ for (_i690 = 0; _i690 < _size686; ++_i690)
{
- xfer += iprot->readString(this->filesAddedChecksum[_i660]);
+ xfer += iprot->readString(this->filesAddedChecksum[_i690]);
}
xfer += iprot->readListEnd();
}
@@ -16219,10 +16716,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAdded.size()));
- std::vector<std::string> ::const_iterator _iter661;
- for (_iter661 = this->filesAdded.begin(); _iter661 != this->filesAdded.end(); ++_iter661)
+ std::vector<std::string> ::const_iterator _iter691;
+ for (_iter691 = this->filesAdded.begin(); _iter691 != this->filesAdded.end(); ++_iter691)
{
- xfer += oprot->writeString((*_iter661));
+ xfer += oprot->writeString((*_iter691));
}
xfer += oprot->writeListEnd();
}
@@ -16232,10 +16729,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAddedChecksum.size()));
- std::vector<std::string> ::const_iterator _iter662;
- for (_iter662 = this->filesAddedChecksum.begin(); _iter662 != this->filesAddedChecksum.end(); ++_iter662)
+ std::vector<std::string> ::const_iterator _iter692;
+ for (_iter692 = this->filesAddedChecksum.begin(); _iter692 != this->filesAddedChecksum.end(); ++_iter692)
{
- xfer += oprot->writeString((*_iter662));
+ xfer += oprot->writeString((*_iter692));
}
xfer += oprot->writeListEnd();
}
@@ -16253,15 +16750,15 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) {
swap(a.__isset, b.__isset);
}
-InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other663) {
- filesAdded = other663.filesAdded;
- filesAddedChecksum = other663.filesAddedChecksum;
- __isset = other663.__isset;
+InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other693) {
+ filesAdded = other693.filesAdded;
+ filesAddedChecksum = other693.filesAddedChecksum;
+ __isset = other693.__isset;
}
-InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other664) {
- filesAdded = other664.filesAdded;
- filesAddedChecksum = other664.filesAddedChecksum;
- __isset = other664.__isset;
+InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other694) {
+ filesAdded = other694.filesAdded;
+ filesAddedChecksum = other694.filesAddedChecksum;
+ __isset = other694.__isset;
return *this;
}
void InsertEventRequestData::printTo(std::ostream& out) const {
@@ -16342,13 +16839,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) {
swap(a.__isset, b.__isset);
}
-FireEventRequestData::FireEventRequestData(const FireEventRequestData& other665) {
- insertData = other665.insertData;
- __isset = other665.__isset;
+FireEventRequestData::FireEventRequestData(const FireEventRequestData& other695) {
+ insertData = other695.insertData;
+ __isset = other695.__isset;
}
-FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other666) {
- insertData = other666.insertData;
- __isset = other666.__isset;
+FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other696) {
+ insertData = other696.insertData;
+ __isset = other696.__isset;
return *this;
}
void FireEventRequestData::printTo(std::ostream& out) const {
@@ -16445,14 +16942,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionVals.clear();
- uint32_t _size667;
- ::apache::thrift::protocol::TType _etype670;
- xfer += iprot->readListBegin(_etype670, _size667);
- this->partitionVals.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->partitionVals.resize(_size697);
+ uint32_t _i701;
+ for (_i701 = 0; _i701 < _size697; ++_i701)
{
- xfer += iprot->readString(this->partitionVals[_i671]);
+ xfer += iprot->readString(this->partitionVals[_i701]);
}
xfer += iprot->readListEnd();
}
@@ -16504,10 +17001,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionVals.size()));
- std::vector<std::string> ::const_iterator _iter672;
- for (_iter672 = this->partitionVals.begin(); _iter672 != this->partitionVals.end(); ++_iter672)
+ std::vector<std::string> ::const_iterator _iter702;
+ for (_iter702 = this->partitionVals.begin(); _iter702 != this->partitionVals.end(); ++_iter702)
{
- xfer += oprot->writeString((*_iter672));
+ xfer += oprot->writeString((*_iter702));
}
xfer += oprot->writeListEnd();
}
@@ -16528,21 +17025,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) {
swap(a.__isset, b.__isset);
}
-FireEventRequest::FireEventRequest(const FireEventRequest& other673) {
- successful = other673.successful;
- data = other673.data;
- dbName = other673.dbName;
- tableName = other673.tableName;
- partitionVals = other673.partitionVals;
- __isset = other673.__isset;
-}
-FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other674) {
- successful = other674.successful;
- data = other674.data;
- dbName = othe
<TRUNCATED>