You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by we...@apache.org on 2017/05/08 22:18:04 UTC
[47/50] [abbrv] hive git commit: HIVE-14671 : merge master into
hive-14535 (Wei Zheng)
http://git-wip-us.apache.org/repos/asf/hive/blob/1ceaf357/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 96c2b0b,e3725a5..cfa2e49
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@@ -18058,26 -18056,25 +18102,26 @@@ uint32_t GetNextWriteIdRequest::write(:
return xfer;
}
-void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) {
+void swap(GetNextWriteIdRequest &a, GetNextWriteIdRequest &b) {
using ::std::swap;
- swap(a.functions, b.functions);
- swap(a.__isset, b.__isset);
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
}
- GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other747) {
-GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other752) {
- functions = other752.functions;
- __isset = other752.__isset;
++GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other746) {
++ dbName = other746.dbName;
++ tblName = other746.tblName;
+ }
-GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other753) {
- functions = other753.functions;
- __isset = other753.__isset;
++GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other747) {
+ dbName = other747.dbName;
+ tblName = other747.tblName;
- }
- GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other748) {
- dbName = other748.dbName;
- tblName = other748.tblName;
return *this;
}
-void GetAllFunctionsResponse::printTo(std::ostream& out) const {
+void GetNextWriteIdRequest::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "GetAllFunctionsResponse(";
- out << "functions="; (__isset.functions ? (out << to_string(functions)) : (out << "<null>"));
+ out << "GetNextWriteIdRequest(";
+ out << "dbName=" << to_string(dbName);
+ out << ", " << "tblName=" << to_string(tblName);
out << ")";
}
@@@ -18148,22 -18167,22 +18192,22 @@@ uint32_t GetNextWriteIdResult::write(::
return xfer;
}
-void swap(ClientCapabilities &a, ClientCapabilities &b) {
+void swap(GetNextWriteIdResult &a, GetNextWriteIdResult &b) {
using ::std::swap;
- swap(a.values, b.values);
+ swap(a.writeId, b.writeId);
}
- GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other749) {
- writeId = other749.writeId;
-ClientCapabilities::ClientCapabilities(const ClientCapabilities& other761) {
- values = other761.values;
++GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other748) {
++ writeId = other748.writeId;
}
- GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other750) {
- writeId = other750.writeId;
-ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other762) {
- values = other762.values;
++GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other749) {
++ writeId = other749.writeId;
return *this;
}
-void ClientCapabilities::printTo(std::ostream& out) const {
+void GetNextWriteIdResult::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "ClientCapabilities(";
- out << "values=" << to_string(values);
+ out << "GetNextWriteIdResult(";
+ out << "writeId=" << to_string(writeId);
out << ")";
}
@@@ -18295,30 -18294,29 +18339,30 @@@ void swap(FinalizeWriteIdRequest &a, Fi
using ::std::swap;
swap(a.dbName, b.dbName);
swap(a.tblName, b.tblName);
- swap(a.capabilities, b.capabilities);
- swap(a.__isset, b.__isset);
+ swap(a.writeId, b.writeId);
+ swap(a.commit, b.commit);
}
- FinalizeWriteIdRequest::FinalizeWriteIdRequest(const FinalizeWriteIdRequest& other751) {
-GetTableRequest::GetTableRequest(const GetTableRequest& other763) {
- dbName = other763.dbName;
- tblName = other763.tblName;
- capabilities = other763.capabilities;
- __isset = other763.__isset;
++FinalizeWriteIdRequest::FinalizeWriteIdRequest(const FinalizeWriteIdRequest& other750) {
++ dbName = other750.dbName;
++ tblName = other750.tblName;
++ writeId = other750.writeId;
++ commit = other750.commit;
+ }
-GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other764) {
- dbName = other764.dbName;
- tblName = other764.tblName;
- capabilities = other764.capabilities;
- __isset = other764.__isset;
++FinalizeWriteIdRequest& FinalizeWriteIdRequest::operator=(const FinalizeWriteIdRequest& other751) {
+ dbName = other751.dbName;
+ tblName = other751.tblName;
+ writeId = other751.writeId;
+ commit = other751.commit;
- }
- FinalizeWriteIdRequest& FinalizeWriteIdRequest::operator=(const FinalizeWriteIdRequest& other752) {
- dbName = other752.dbName;
- tblName = other752.tblName;
- writeId = other752.writeId;
- commit = other752.commit;
return *this;
}
-void GetTableRequest::printTo(std::ostream& out) const {
+void FinalizeWriteIdRequest::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "GetTableRequest(";
+ out << "FinalizeWriteIdRequest(";
out << "dbName=" << to_string(dbName);
out << ", " << "tblName=" << to_string(tblName);
- out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
+ out << ", " << "writeId=" << to_string(writeId);
+ out << ", " << "commit=" << to_string(commit);
out << ")";
}
@@@ -18365,22 -18387,22 +18409,22 @@@ uint32_t FinalizeWriteIdResult::write(:
return xfer;
}
-void swap(GetTableResult &a, GetTableResult &b) {
+void swap(FinalizeWriteIdResult &a, FinalizeWriteIdResult &b) {
using ::std::swap;
- swap(a.table, b.table);
+ (void) a;
+ (void) b;
}
- FinalizeWriteIdResult::FinalizeWriteIdResult(const FinalizeWriteIdResult& other753) {
- (void) other753;
-GetTableResult::GetTableResult(const GetTableResult& other765) {
- table = other765.table;
++FinalizeWriteIdResult::FinalizeWriteIdResult(const FinalizeWriteIdResult& other752) {
++ (void) other752;
}
- FinalizeWriteIdResult& FinalizeWriteIdResult::operator=(const FinalizeWriteIdResult& other754) {
- (void) other754;
-GetTableResult& GetTableResult::operator=(const GetTableResult& other766) {
- table = other766.table;
++FinalizeWriteIdResult& FinalizeWriteIdResult::operator=(const FinalizeWriteIdResult& other753) {
++ (void) other753;
return *this;
}
-void GetTableResult::printTo(std::ostream& out) const {
+void FinalizeWriteIdResult::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "GetTableResult(";
- out << "table=" << to_string(table);
+ out << "FinalizeWriteIdResult(";
out << ")";
}
@@@ -18489,30 -18529,33 +18533,30 @@@ uint32_t HeartbeatWriteIdRequest::write
return xfer;
}
-void swap(GetTablesRequest &a, GetTablesRequest &b) {
+void swap(HeartbeatWriteIdRequest &a, HeartbeatWriteIdRequest &b) {
using ::std::swap;
swap(a.dbName, b.dbName);
- swap(a.tblNames, b.tblNames);
- swap(a.capabilities, b.capabilities);
- swap(a.__isset, b.__isset);
+ swap(a.tblName, b.tblName);
+ swap(a.writeId, b.writeId);
}
- HeartbeatWriteIdRequest::HeartbeatWriteIdRequest(const HeartbeatWriteIdRequest& other755) {
-GetTablesRequest::GetTablesRequest(const GetTablesRequest& other773) {
- dbName = other773.dbName;
- tblNames = other773.tblNames;
- capabilities = other773.capabilities;
- __isset = other773.__isset;
++HeartbeatWriteIdRequest::HeartbeatWriteIdRequest(const HeartbeatWriteIdRequest& other754) {
++ dbName = other754.dbName;
++ tblName = other754.tblName;
++ writeId = other754.writeId;
+ }
-GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other774) {
- dbName = other774.dbName;
- tblNames = other774.tblNames;
- capabilities = other774.capabilities;
- __isset = other774.__isset;
++HeartbeatWriteIdRequest& HeartbeatWriteIdRequest::operator=(const HeartbeatWriteIdRequest& other755) {
+ dbName = other755.dbName;
+ tblName = other755.tblName;
+ writeId = other755.writeId;
- }
- HeartbeatWriteIdRequest& HeartbeatWriteIdRequest::operator=(const HeartbeatWriteIdRequest& other756) {
- dbName = other756.dbName;
- tblName = other756.tblName;
- writeId = other756.writeId;
return *this;
}
-void GetTablesRequest::printTo(std::ostream& out) const {
+void HeartbeatWriteIdRequest::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "GetTablesRequest(";
+ out << "HeartbeatWriteIdRequest(";
out << "dbName=" << to_string(dbName);
- out << ", " << "tblNames="; (__isset.tblNames ? (out << to_string(tblNames)) : (out << "<null>"));
- out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
+ out << ", " << "tblName=" << to_string(tblName);
+ out << ", " << "writeId=" << to_string(writeId);
out << ")";
}
@@@ -18521,947 -18564,11 +18565,947 @@@ HeartbeatWriteIdResult::~HeartbeatWrite
}
-void GetTablesResult::__set_tables(const std::vector<Table> & val) {
- this->tables = val;
-}
-
-uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t HeartbeatWriteIdResult::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;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t HeartbeatWriteIdResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("HeartbeatWriteIdResult");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(HeartbeatWriteIdResult &a, HeartbeatWriteIdResult &b) {
+ using ::std::swap;
+ (void) a;
+ (void) b;
+}
+
- HeartbeatWriteIdResult::HeartbeatWriteIdResult(const HeartbeatWriteIdResult& other757) {
- (void) other757;
++HeartbeatWriteIdResult::HeartbeatWriteIdResult(const HeartbeatWriteIdResult& other756) {
++ (void) other756;
+}
- HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other758) {
- (void) other758;
++HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other757) {
++ (void) other757;
+ return *this;
+}
+void HeartbeatWriteIdResult::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "HeartbeatWriteIdResult(";
+ out << ")";
+}
+
+
+GetValidWriteIdsRequest::~GetValidWriteIdsRequest() throw() {
+}
+
+
+void GetValidWriteIdsRequest::__set_dbName(const std::string& val) {
+ this->dbName = val;
+}
+
+void GetValidWriteIdsRequest::__set_tblName(const std::string& val) {
+ this->tblName = val;
+}
+
+uint32_t GetValidWriteIdsRequest::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;
+
+ 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;
+ 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);
+ return xfer;
+}
+
+uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetValidWriteIdsRequest");
+
+ 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->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
+}
+
- GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other759) {
++GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other758) {
++ dbName = other758.dbName;
++ tblName = other758.tblName;
++}
++GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other759) {
+ dbName = other759.dbName;
+ tblName = other759.tblName;
- }
- GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other760) {
- dbName = other760.dbName;
- tblName = other760.tblName;
+ return *this;
+}
+void GetValidWriteIdsRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetValidWriteIdsRequest(";
+ out << "dbName=" << to_string(dbName);
+ out << ", " << "tblName=" << to_string(tblName);
+ out << ")";
+}
+
+
+GetValidWriteIdsResult::~GetValidWriteIdsResult() throw() {
+}
+
+
+void GetValidWriteIdsResult::__set_lowWatermarkId(const int64_t val) {
+ this->lowWatermarkId = val;
+}
+
+void GetValidWriteIdsResult::__set_highWatermarkId(const int64_t val) {
+ this->highWatermarkId = val;
+}
+
+void GetValidWriteIdsResult::__set_areIdsValid(const bool val) {
+ this->areIdsValid = val;
+__isset.areIdsValid = true;
+}
+
+void GetValidWriteIdsResult::__set_ids(const std::vector<int64_t> & val) {
+ this->ids = val;
+__isset.ids = true;
+}
+
+uint32_t GetValidWriteIdsResult::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_lowWatermarkId = false;
+ bool isset_highWatermarkId = 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_I64) {
+ xfer += iprot->readI64(this->lowWatermarkId);
+ isset_lowWatermarkId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->highWatermarkId);
+ isset_highWatermarkId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->areIdsValid);
+ this->__isset.areIdsValid = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->ids.clear();
- uint32_t _size761;
- ::apache::thrift::protocol::TType _etype764;
- xfer += iprot->readListBegin(_etype764, _size761);
- this->ids.resize(_size761);
- uint32_t _i765;
- for (_i765 = 0; _i765 < _size761; ++_i765)
++ uint32_t _size760;
++ ::apache::thrift::protocol::TType _etype763;
++ xfer += iprot->readListBegin(_etype763, _size760);
++ this->ids.resize(_size760);
++ uint32_t _i764;
++ for (_i764 = 0; _i764 < _size760; ++_i764)
+ {
- xfer += iprot->readI64(this->ids[_i765]);
++ xfer += iprot->readI64(this->ids[_i764]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.ids = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_lowWatermarkId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_highWatermarkId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t GetValidWriteIdsResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetValidWriteIdsResult");
+
+ xfer += oprot->writeFieldBegin("lowWatermarkId", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->lowWatermarkId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("highWatermarkId", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->highWatermarkId);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.areIdsValid) {
+ xfer += oprot->writeFieldBegin("areIdsValid", ::apache::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool(this->areIdsValid);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.ids) {
+ xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->ids.size()));
- std::vector<int64_t> ::const_iterator _iter766;
- for (_iter766 = this->ids.begin(); _iter766 != this->ids.end(); ++_iter766)
++ std::vector<int64_t> ::const_iterator _iter765;
++ for (_iter765 = this->ids.begin(); _iter765 != this->ids.end(); ++_iter765)
+ {
- xfer += oprot->writeI64((*_iter766));
++ xfer += oprot->writeI64((*_iter765));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetValidWriteIdsResult &a, GetValidWriteIdsResult &b) {
+ using ::std::swap;
+ swap(a.lowWatermarkId, b.lowWatermarkId);
+ swap(a.highWatermarkId, b.highWatermarkId);
+ swap(a.areIdsValid, b.areIdsValid);
+ swap(a.ids, b.ids);
+ swap(a.__isset, b.__isset);
+}
+
- GetValidWriteIdsResult::GetValidWriteIdsResult(const GetValidWriteIdsResult& other767) {
++GetValidWriteIdsResult::GetValidWriteIdsResult(const GetValidWriteIdsResult& other766) {
++ lowWatermarkId = other766.lowWatermarkId;
++ highWatermarkId = other766.highWatermarkId;
++ areIdsValid = other766.areIdsValid;
++ ids = other766.ids;
++ __isset = other766.__isset;
++}
++GetValidWriteIdsResult& GetValidWriteIdsResult::operator=(const GetValidWriteIdsResult& other767) {
+ lowWatermarkId = other767.lowWatermarkId;
+ highWatermarkId = other767.highWatermarkId;
+ areIdsValid = other767.areIdsValid;
+ ids = other767.ids;
+ __isset = other767.__isset;
- }
- GetValidWriteIdsResult& GetValidWriteIdsResult::operator=(const GetValidWriteIdsResult& other768) {
- lowWatermarkId = other768.lowWatermarkId;
- highWatermarkId = other768.highWatermarkId;
- areIdsValid = other768.areIdsValid;
- ids = other768.ids;
- __isset = other768.__isset;
+ return *this;
+}
+void GetValidWriteIdsResult::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetValidWriteIdsResult(";
+ out << "lowWatermarkId=" << to_string(lowWatermarkId);
+ out << ", " << "highWatermarkId=" << to_string(highWatermarkId);
+ out << ", " << "areIdsValid="; (__isset.areIdsValid ? (out << to_string(areIdsValid)) : (out << "<null>"));
+ out << ", " << "ids="; (__isset.ids ? (out << to_string(ids)) : (out << "<null>"));
+ out << ")";
+}
+
+
+GetAllFunctionsResponse::~GetAllFunctionsResponse() throw() {
+}
+
+
+void GetAllFunctionsResponse::__set_functions(const std::vector<Function> & val) {
+ this->functions = val;
+__isset.functions = true;
+}
+
+uint32_t GetAllFunctionsResponse::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;
+
+
+ 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->functions.clear();
- uint32_t _size769;
- ::apache::thrift::protocol::TType _etype772;
- xfer += iprot->readListBegin(_etype772, _size769);
- this->functions.resize(_size769);
- uint32_t _i773;
- for (_i773 = 0; _i773 < _size769; ++_i773)
++ uint32_t _size768;
++ ::apache::thrift::protocol::TType _etype771;
++ xfer += iprot->readListBegin(_etype771, _size768);
++ this->functions.resize(_size768);
++ uint32_t _i772;
++ for (_i772 = 0; _i772 < _size768; ++_i772)
+ {
- xfer += this->functions[_i773].read(iprot);
++ xfer += this->functions[_i772].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.functions = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetAllFunctionsResponse");
+
+ if (this->__isset.functions) {
+ xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->functions.size()));
- std::vector<Function> ::const_iterator _iter774;
- for (_iter774 = this->functions.begin(); _iter774 != this->functions.end(); ++_iter774)
++ std::vector<Function> ::const_iterator _iter773;
++ for (_iter773 = this->functions.begin(); _iter773 != this->functions.end(); ++_iter773)
+ {
- xfer += (*_iter774).write(oprot);
++ xfer += (*_iter773).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) {
+ using ::std::swap;
+ swap(a.functions, b.functions);
+ swap(a.__isset, b.__isset);
+}
+
- GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other775) {
++GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other774) {
++ functions = other774.functions;
++ __isset = other774.__isset;
++}
++GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other775) {
+ functions = other775.functions;
+ __isset = other775.__isset;
- }
- GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other776) {
- functions = other776.functions;
- __isset = other776.__isset;
+ return *this;
+}
+void GetAllFunctionsResponse::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetAllFunctionsResponse(";
+ out << "functions="; (__isset.functions ? (out << to_string(functions)) : (out << "<null>"));
+ out << ")";
+}
+
+
+ClientCapabilities::~ClientCapabilities() throw() {
+}
+
+
+void ClientCapabilities::__set_values(const std::vector<ClientCapability::type> & val) {
+ this->values = val;
+}
+
+uint32_t ClientCapabilities::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_values = 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->values.clear();
- uint32_t _size777;
- ::apache::thrift::protocol::TType _etype780;
- xfer += iprot->readListBegin(_etype780, _size777);
- this->values.resize(_size777);
- uint32_t _i781;
- for (_i781 = 0; _i781 < _size777; ++_i781)
++ uint32_t _size776;
++ ::apache::thrift::protocol::TType _etype779;
++ xfer += iprot->readListBegin(_etype779, _size776);
++ this->values.resize(_size776);
++ uint32_t _i780;
++ for (_i780 = 0; _i780 < _size776; ++_i780)
+ {
- int32_t ecast782;
- xfer += iprot->readI32(ecast782);
- this->values[_i781] = (ClientCapability::type)ecast782;
++ int32_t ecast781;
++ xfer += iprot->readI32(ecast781);
++ this->values[_i780] = (ClientCapability::type)ecast781;
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_values)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("ClientCapabilities");
+
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->values.size()));
- std::vector<ClientCapability::type> ::const_iterator _iter783;
- for (_iter783 = this->values.begin(); _iter783 != this->values.end(); ++_iter783)
++ std::vector<ClientCapability::type> ::const_iterator _iter782;
++ for (_iter782 = this->values.begin(); _iter782 != this->values.end(); ++_iter782)
+ {
- xfer += oprot->writeI32((int32_t)(*_iter783));
++ xfer += oprot->writeI32((int32_t)(*_iter782));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ClientCapabilities &a, ClientCapabilities &b) {
+ using ::std::swap;
+ swap(a.values, b.values);
+}
+
- ClientCapabilities::ClientCapabilities(const ClientCapabilities& other784) {
- values = other784.values;
++ClientCapabilities::ClientCapabilities(const ClientCapabilities& other783) {
++ values = other783.values;
+}
- ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other785) {
- values = other785.values;
++ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other784) {
++ values = other784.values;
+ return *this;
+}
+void ClientCapabilities::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "ClientCapabilities(";
+ out << "values=" << to_string(values);
+ out << ")";
+}
+
+
+GetTableRequest::~GetTableRequest() throw() {
+}
+
+
+void GetTableRequest::__set_dbName(const std::string& val) {
+ this->dbName = val;
+}
+
+void GetTableRequest::__set_tblName(const std::string& val) {
+ this->tblName = val;
+}
+
+void GetTableRequest::__set_capabilities(const ClientCapabilities& val) {
+ this->capabilities = val;
+__isset.capabilities = true;
+}
+
+uint32_t GetTableRequest::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;
+
+ 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_STRUCT) {
+ xfer += this->capabilities.read(iprot);
+ this->__isset.capabilities = 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);
+ return xfer;
+}
+
+uint32_t GetTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetTableRequest");
+
+ 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();
+
+ if (this->__isset.capabilities) {
+ xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->capabilities.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetTableRequest &a, GetTableRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
+ swap(a.capabilities, b.capabilities);
+ swap(a.__isset, b.__isset);
+}
+
- GetTableRequest::GetTableRequest(const GetTableRequest& other786) {
++GetTableRequest::GetTableRequest(const GetTableRequest& other785) {
++ dbName = other785.dbName;
++ tblName = other785.tblName;
++ capabilities = other785.capabilities;
++ __isset = other785.__isset;
++}
++GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other786) {
+ dbName = other786.dbName;
+ tblName = other786.tblName;
+ capabilities = other786.capabilities;
+ __isset = other786.__isset;
- }
- GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other787) {
- dbName = other787.dbName;
- tblName = other787.tblName;
- capabilities = other787.capabilities;
- __isset = other787.__isset;
+ return *this;
+}
+void GetTableRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetTableRequest(";
+ out << "dbName=" << to_string(dbName);
+ out << ", " << "tblName=" << to_string(tblName);
+ out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
+ out << ")";
+}
+
+
+GetTableResult::~GetTableResult() throw() {
+}
+
+
+void GetTableResult::__set_table(const Table& val) {
+ this->table = val;
+}
+
+uint32_t GetTableResult::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_table = 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_STRUCT) {
+ xfer += this->table.read(iprot);
+ isset_table = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_table)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t GetTableResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetTableResult");
+
+ xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->table.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetTableResult &a, GetTableResult &b) {
+ using ::std::swap;
+ swap(a.table, b.table);
+}
+
- GetTableResult::GetTableResult(const GetTableResult& other788) {
- table = other788.table;
++GetTableResult::GetTableResult(const GetTableResult& other787) {
++ table = other787.table;
+}
- GetTableResult& GetTableResult::operator=(const GetTableResult& other789) {
- table = other789.table;
++GetTableResult& GetTableResult::operator=(const GetTableResult& other788) {
++ table = other788.table;
+ return *this;
+}
+void GetTableResult::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetTableResult(";
+ out << "table=" << to_string(table);
+ out << ")";
+}
+
+
+GetTablesRequest::~GetTablesRequest() throw() {
+}
+
+
+void GetTablesRequest::__set_dbName(const std::string& val) {
+ this->dbName = val;
+}
+
+void GetTablesRequest::__set_tblNames(const std::vector<std::string> & val) {
+ this->tblNames = val;
+__isset.tblNames = true;
+}
+
+void GetTablesRequest::__set_capabilities(const ClientCapabilities& val) {
+ this->capabilities = val;
+__isset.capabilities = true;
+}
+
+uint32_t GetTablesRequest::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;
+
+ 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_LIST) {
+ {
+ this->tblNames.clear();
- uint32_t _size790;
- ::apache::thrift::protocol::TType _etype793;
- xfer += iprot->readListBegin(_etype793, _size790);
- this->tblNames.resize(_size790);
- uint32_t _i794;
- for (_i794 = 0; _i794 < _size790; ++_i794)
++ uint32_t _size789;
++ ::apache::thrift::protocol::TType _etype792;
++ xfer += iprot->readListBegin(_etype792, _size789);
++ this->tblNames.resize(_size789);
++ uint32_t _i793;
++ for (_i793 = 0; _i793 < _size789; ++_i793)
+ {
- xfer += iprot->readString(this->tblNames[_i794]);
++ xfer += iprot->readString(this->tblNames[_i793]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.tblNames = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->capabilities.read(iprot);
+ this->__isset.capabilities = 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);
+ return xfer;
+}
+
+uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetTablesRequest");
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.tblNames) {
+ xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tblNames.size()));
- std::vector<std::string> ::const_iterator _iter795;
- for (_iter795 = this->tblNames.begin(); _iter795 != this->tblNames.end(); ++_iter795)
++ std::vector<std::string> ::const_iterator _iter794;
++ for (_iter794 = this->tblNames.begin(); _iter794 != this->tblNames.end(); ++_iter794)
+ {
- xfer += oprot->writeString((*_iter795));
++ xfer += oprot->writeString((*_iter794));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.capabilities) {
+ xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->capabilities.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetTablesRequest &a, GetTablesRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblNames, b.tblNames);
+ swap(a.capabilities, b.capabilities);
+ swap(a.__isset, b.__isset);
+}
+
- GetTablesRequest::GetTablesRequest(const GetTablesRequest& other796) {
++GetTablesRequest::GetTablesRequest(const GetTablesRequest& other795) {
++ dbName = other795.dbName;
++ tblNames = other795.tblNames;
++ capabilities = other795.capabilities;
++ __isset = other795.__isset;
++}
++GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other796) {
+ dbName = other796.dbName;
+ tblNames = other796.tblNames;
+ capabilities = other796.capabilities;
+ __isset = other796.__isset;
- }
- GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other797) {
- dbName = other797.dbName;
- tblNames = other797.tblNames;
- capabilities = other797.capabilities;
- __isset = other797.__isset;
+ return *this;
+}
+void GetTablesRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetTablesRequest(";
+ out << "dbName=" << to_string(dbName);
+ out << ", " << "tblNames="; (__isset.tblNames ? (out << to_string(tblNames)) : (out << "<null>"));
+ out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
+ out << ")";
+}
+
+
+GetTablesResult::~GetTablesResult() throw() {
+}
+
+
+void GetTablesResult::__set_tables(const std::vector<Table> & val) {
+ this->tables = val;
+}
+
+uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
uint32_t xfer = 0;
@@@ -19487,14 -18594,14 +19531,14 @@@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tables.clear();
- uint32_t _size798;
- ::apache::thrift::protocol::TType _etype801;
- xfer += iprot->readListBegin(_etype801, _size798);
- this->tables.resize(_size798);
- uint32_t _i802;
- for (_i802 = 0; _i802 < _size798; ++_i802)
- uint32_t _size775;
- ::apache::thrift::protocol::TType _etype778;
- xfer += iprot->readListBegin(_etype778, _size775);
- this->tables.resize(_size775);
- uint32_t _i779;
- for (_i779 = 0; _i779 < _size775; ++_i779)
++ uint32_t _size797;
++ ::apache::thrift::protocol::TType _etype800;
++ xfer += iprot->readListBegin(_etype800, _size797);
++ this->tables.resize(_size797);
++ uint32_t _i801;
++ for (_i801 = 0; _i801 < _size797; ++_i801)
{
- xfer += this->tables[_i802].read(iprot);
- xfer += this->tables[_i779].read(iprot);
++ xfer += this->tables[_i801].read(iprot);
}
xfer += iprot->readListEnd();
}
@@@ -19525,10 -18632,10 +19569,10 @@@ uint32_t GetTablesResult::write(::apach
xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tables.size()));
- std::vector<Table> ::const_iterator _iter803;
- for (_iter803 = this->tables.begin(); _iter803 != this->tables.end(); ++_iter803)
- std::vector<Table> ::const_iterator _iter780;
- for (_iter780 = this->tables.begin(); _iter780 != this->tables.end(); ++_iter780)
++ std::vector<Table> ::const_iterator _iter802;
++ for (_iter802 = this->tables.begin(); _iter802 != this->tables.end(); ++_iter802)
{
- xfer += (*_iter803).write(oprot);
- xfer += (*_iter780).write(oprot);
++ xfer += (*_iter802).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@@ -19544,11 -18651,11 +19588,11 @@@ void swap(GetTablesResult &a, GetTables
swap(a.tables, b.tables);
}
- GetTablesResult::GetTablesResult(const GetTablesResult& other804) {
- tables = other804.tables;
-GetTablesResult::GetTablesResult(const GetTablesResult& other781) {
- tables = other781.tables;
++GetTablesResult::GetTablesResult(const GetTablesResult& other803) {
++ tables = other803.tables;
}
- GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other805) {
- tables = other805.tables;
-GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other782) {
- tables = other782.tables;
++GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other804) {
++ tables = other804.tables;
return *this;
}
void GetTablesResult::printTo(std::ostream& out) const {
@@@ -19690,19 -18797,19 +19734,19 @@@ void swap(TableMeta &a, TableMeta &b)
swap(a.__isset, b.__isset);
}
- TableMeta::TableMeta(const TableMeta& other806) {
-TableMeta::TableMeta(const TableMeta& other783) {
- dbName = other783.dbName;
- tableName = other783.tableName;
- tableType = other783.tableType;
- comments = other783.comments;
- __isset = other783.__isset;
++TableMeta::TableMeta(const TableMeta& other805) {
++ dbName = other805.dbName;
++ tableName = other805.tableName;
++ tableType = other805.tableType;
++ comments = other805.comments;
++ __isset = other805.__isset;
+ }
-TableMeta& TableMeta::operator=(const TableMeta& other784) {
- dbName = other784.dbName;
- tableName = other784.tableName;
- tableType = other784.tableType;
- comments = other784.comments;
- __isset = other784.__isset;
++TableMeta& TableMeta::operator=(const TableMeta& other806) {
+ dbName = other806.dbName;
+ tableName = other806.tableName;
+ tableType = other806.tableType;
+ comments = other806.comments;
+ __isset = other806.__isset;
- }
- TableMeta& TableMeta::operator=(const TableMeta& other807) {
- dbName = other807.dbName;
- tableName = other807.tableName;
- tableType = other807.tableType;
- comments = other807.comments;
- __isset = other807.__isset;
return *this;
}
void TableMeta::printTo(std::ostream& out) const {
@@@ -19785,13 -18892,13 +19829,13 @@@ void swap(MetaException &a, MetaExcepti
swap(a.__isset, b.__isset);
}
- MetaException::MetaException(const MetaException& other808) : TException() {
-MetaException::MetaException(const MetaException& other785) : TException() {
- message = other785.message;
- __isset = other785.__isset;
++MetaException::MetaException(const MetaException& other807) : TException() {
++ message = other807.message;
++ __isset = other807.__isset;
+ }
-MetaException& MetaException::operator=(const MetaException& other786) {
- message = other786.message;
- __isset = other786.__isset;
++MetaException& MetaException::operator=(const MetaException& other808) {
+ message = other808.message;
+ __isset = other808.__isset;
- }
- MetaException& MetaException::operator=(const MetaException& other809) {
- message = other809.message;
- __isset = other809.__isset;
return *this;
}
void MetaException::printTo(std::ostream& out) const {
@@@ -19882,13 -18989,13 +19926,13 @@@ void swap(UnknownTableException &a, Unk
swap(a.__isset, b.__isset);
}
- UnknownTableException::UnknownTableException(const UnknownTableException& other810) : TException() {
-UnknownTableException::UnknownTableException(const UnknownTableException& other787) : TException() {
- message = other787.message;
- __isset = other787.__isset;
++UnknownTableException::UnknownTableException(const UnknownTableException& other809) : TException() {
++ message = other809.message;
++ __isset = other809.__isset;
+ }
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other788) {
- message = other788.message;
- __isset = other788.__isset;
++UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other810) {
+ message = other810.message;
+ __isset = other810.__isset;
- }
- UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other811) {
- message = other811.message;
- __isset = other811.__isset;
return *this;
}
void UnknownTableException::printTo(std::ostream& out) const {
@@@ -19979,13 -19086,13 +20023,13 @@@ void swap(UnknownDBException &a, Unknow
swap(a.__isset, b.__isset);
}
- UnknownDBException::UnknownDBException(const UnknownDBException& other812) : TException() {
-UnknownDBException::UnknownDBException(const UnknownDBException& other789) : TException() {
- message = other789.message;
- __isset = other789.__isset;
++UnknownDBException::UnknownDBException(const UnknownDBException& other811) : TException() {
++ message = other811.message;
++ __isset = other811.__isset;
+ }
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other790) {
- message = other790.message;
- __isset = other790.__isset;
++UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other812) {
+ message = other812.message;
+ __isset = other812.__isset;
- }
- UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other813) {
- message = other813.message;
- __isset = other813.__isset;
return *this;
}
void UnknownDBException::printTo(std::ostream& out) const {
@@@ -20076,13 -19183,13 +20120,13 @@@ void swap(AlreadyExistsException &a, Al
swap(a.__isset, b.__isset);
}
- AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other814) : TException() {
-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other791) : TException() {
- message = other791.message;
- __isset = other791.__isset;
++AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other813) : TException() {
++ message = other813.message;
++ __isset = other813.__isset;
+ }
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other792) {
- message = other792.message;
- __isset = other792.__isset;
++AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other814) {
+ message = other814.message;
+ __isset = other814.__isset;
- }
- AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other815) {
- message = other815.message;
- __isset = other815.__isset;
return *this;
}
void AlreadyExistsException::printTo(std::ostream& out) const {
@@@ -20173,13 -19280,13 +20217,13 @@@ void swap(InvalidPartitionException &a
swap(a.__isset, b.__isset);
}
- InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other816) : TException() {
-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other793) : TException() {
- message = other793.message;
- __isset = other793.__isset;
++InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other815) : TException() {
++ message = other815.message;
++ __isset = other815.__isset;
+ }
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other794) {
- message = other794.message;
- __isset = other794.__isset;
++InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other816) {
+ message = other816.message;
+ __isset = other816.__isset;
- }
- InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other817) {
- message = other817.message;
- __isset = other817.__isset;
return *this;
}
void InvalidPartitionException::printTo(std::ostream& out) const {
@@@ -20270,13 -19377,13 +20314,13 @@@ void swap(UnknownPartitionException &a
swap(a.__isset, b.__isset);
}
- UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other818) : TException() {
-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other795) : TException() {
- message = other795.message;
- __isset = other795.__isset;
++UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other817) : TException() {
++ message = other817.message;
++ __isset = other817.__isset;
+ }
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other796) {
- message = other796.message;
- __isset = other796.__isset;
++UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other818) {
+ message = other818.message;
+ __isset = other818.__isset;
- }
- UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other819) {
- message = other819.message;
- __isset = other819.__isset;
return *this;
}
void UnknownPartitionException::printTo(std::ostream& out) const {
@@@ -20367,13 -19474,13 +20411,13 @@@ void swap(InvalidObjectException &a, In
swap(a.__isset, b.__isset);
}
- InvalidObjectException::InvalidObjectException(const InvalidObjectException& other820) : TException() {
-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other797) : TException() {
- message = other797.message;
- __isset = other797.__isset;
++InvalidObjectException::InvalidObjectException(const InvalidObjectException& other819) : TException() {
++ message = other819.message;
++ __isset = other819.__isset;
+ }
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other798) {
- message = other798.message;
- __isset = other798.__isset;
++InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other820) {
+ message = other820.message;
+ __isset = other820.__isset;
- }
- InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other821) {
- message = other821.message;
- __isset = other821.__isset;
return *this;
}
void InvalidObjectException::printTo(std::ostream& out) const {
@@@ -20464,13 -19571,13 +20508,13 @@@ void swap(NoSuchObjectException &a, NoS
swap(a.__isset, b.__isset);
}
- NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other822) : TException() {
-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other799) : TException() {
- message = other799.message;
- __isset = other799.__isset;
++NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other821) : TException() {
++ message = other821.message;
++ __isset = other821.__isset;
+ }
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other800) {
- message = other800.message;
- __isset = other800.__isset;
++NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other822) {
+ message = other822.message;
+ __isset = other822.__isset;
- }
- NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other823) {
- message = other823.message;
- __isset = other823.__isset;
return *this;
}
void NoSuchObjectException::printTo(std::ostream& out) const {
@@@ -20561,13 -19668,13 +20605,13 @@@ void swap(IndexAlreadyExistsException &
swap(a.__isset, b.__isset);
}
- IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other824) : TException() {
-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other801) : TException() {
- message = other801.message;
- __isset = other801.__isset;
++IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other823) : TException() {
++ message = other823.message;
++ __isset = other823.__isset;
+ }
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other802) {
- message = other802.message;
- __isset = other802.__isset;
++IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other824) {
+ message = other824.message;
+ __isset = other824.__isset;
- }
- IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other825) {
- message = other825.message;
- __isset = other825.__isset;
return *this;
}
void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@@ -20658,13 -19765,13 +20702,13 @@@ void swap(InvalidOperationException &a
swap(a.__isset, b.__isset);
}
- InvalidOperationException::InvalidOperationException(const InvalidOperationException& other826) : TException() {
-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other803) : TException() {
- message = other803.message;
- __isset = other803.__isset;
++InvalidOperationException::InvalidOperationException(const InvalidOperationException& other825) : TException() {
++ message = other825.message;
++ __isset = other825.__isset;
+ }
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other804) {
- message = other804.message;
- __isset = other804.__isset;
++InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other826) {
+ message = other826.message;
+ __isset = other826.__isset;
- }
- InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other827) {
- message = other827.message;
- __isset = other827.__isset;
return *this;
}
void InvalidOperationException::printTo(std::ostream& out) const {
@@@ -20755,13 -19862,13 +20799,13 @@@ void swap(ConfigValSecurityException &a
swap(a.__isset, b.__isset);
}
- ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other828) : TException() {
-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other805) : TException() {
- message = other805.message;
- __isset = other805.__isset;
++ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other827) : TException() {
++ message = other827.message;
++ __isset = other827.__isset;
+ }
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other806) {
- message = other806.message;
- __isset = other806.__isset;
++ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other828) {
+ message = other828.message;
+ __isset = other828.__isset;
- }
- ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other829) {
- message = other829.message;
- __isset = other829.__isset;
return *this;
}
void ConfigValSecurityException::printTo(std::ostream& out) const {
@@@ -20852,13 -19959,13 +20896,13 @@@ void swap(InvalidInputException &a, Inv
swap(a.__isset, b.__isset);
}
- InvalidInputException::InvalidInputException(const InvalidInputException& other830) : TException() {
-InvalidInputException::InvalidInputException(const InvalidInputException& other807) : TException() {
- message = other807.message;
- __isset = other807.__isset;
++InvalidInputException::InvalidInputException(const InvalidInputException& other829) : TException() {
++ message = other829.message;
++ __isset = other829.__isset;
+ }
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other808) {
- message = other808.message;
- __isset = other808.__isset;
++InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other830) {
+ message = other830.message;
+ __isset = other830.__isset;
- }
- InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other831) {
- message = other831.message;
- __isset = other831.__isset;
return *this;
}
void InvalidInputException::printTo(std::ostream& out) const {
@@@ -20949,13 -20056,13 +20993,13 @@@ void swap(NoSuchTxnException &a, NoSuch
swap(a.__isset, b.__isset);
}
- NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other832) : TException() {
-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other809) : TException() {
- message = other809.message;
- __isset = other809.__isset;
++NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other831) : TException() {
++ message = other831.message;
++ __isset = other831.__isset;
+ }
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other810) {
- message = other810.message;
- __isset = other810.__isset;
++NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other832) {
+ message = other832.message;
+ __isset = other832.__isset;
- }
- NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other833) {
- message = other833.message;
- __isset = other833.__isset;
return *this;
}
void NoSuchTxnException::printTo(std::ostream& out) const {
@@@ -21046,13 -20153,13 +21090,13 @@@ void swap(TxnAbortedException &a, TxnAb
swap(a.__isset, b.__isset);
}
- TxnAbortedException::TxnAbortedException(const TxnAbortedException& other834) : TException() {
-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other811) : TException() {
- message = other811.message;
- __isset = other811.__isset;
++TxnAbortedException::TxnAbortedException(const TxnAbortedException& other833) : TException() {
++ message = other833.message;
++ __isset = other833.__isset;
+ }
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other812) {
- message = other812.message;
- __isset = other812.__isset;
++TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other834) {
+ message = other834.message;
+ __isset = other834.__isset;
- }
- TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other835) {
- message = other835.message;
- __isset = other835.__isset;
return *this;
}
void TxnAbortedException::printTo(std::ostream& out) const {
@@@ -21143,13 -20250,13 +21187,13 @@@ void swap(TxnOpenException &a, TxnOpenE
swap(a.__isset, b.__isset);
}
- TxnOpenException::TxnOpenException(const TxnOpenException& other836) : TException() {
-TxnOpenException::TxnOpenException(const TxnOpenException& other813) : TException() {
- message = other813.message;
- __isset = other813.__isset;
++TxnOpenException::TxnOpenException(const TxnOpenException& other835) : TException() {
++ message = other835.message;
++ __isset = other835.__isset;
+ }
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other814) {
- message = other814.message;
- __isset = other814.__isset;
++TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other836) {
+ message = other836.message;
+ __isset = other836.__isset;
- }
- TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other837) {
- message = other837.message;
- __isset = other837.__isset;
return *this;
}
void TxnOpenException::printTo(std::ostream& out) const {
@@@ -21240,13 -20347,13 +21284,13 @@@ void swap(NoSuchLockException &a, NoSuc
swap(a.__isset, b.__isset);
}
- NoSuchLockException::NoSuchLockException(const NoSuchLockException& other838) : TException() {
-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other815) : TException() {
- message = other815.message;
- __isset = other815.__isset;
++NoSuchLockException::NoSuchLockException(const NoSuchLockException& other837) : TException() {
++ message = other837.message;
++ __isset = other837.__isset;
+ }
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other816) {
- message = other816.message;
- __isset = other816.__isset;
++NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other838) {
+ message = other838.message;
+ __isset = other838.__isset;
- }
- NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other839) {
- message = other839.message;
- __isset = other839.__isset;
return *this;
}
void NoSuchLockException::printTo(std::ostream& out) const {
http://git-wip-us.apache.org/repos/asf/hive/blob/1ceaf357/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------