You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2017/02/02 02:03:46 UTC
[47/50] [abbrv] hive git commit: HIVE-14671 : merge master into
hive-14535 (Sergey Shelukhin) UNVERIFIED (build only)
http://git-wip-us.apache.org/repos/asf/hive/blob/748c1bd2/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 7f0ca4e,d605049..a5fa776
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@@ -4481,16 -4479,11 +4481,21 @@@ void Table::__set_temporary(const bool
__isset.temporary = true;
}
+ void Table::__set_rewriteEnabled(const bool val) {
+ this->rewriteEnabled = val;
+ __isset.rewriteEnabled = true;
+ }
+
+void Table::__set_mmNextWriteId(const int64_t val) {
+ this->mmNextWriteId = val;
+__isset.mmNextWriteId = true;
+}
+
+void Table::__set_mmWatermarkWriteId(const int64_t val) {
+ this->mmWatermarkWriteId = val;
+__isset.mmWatermarkWriteId = true;
+}
+
uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
@@@ -4652,21 -4645,13 +4657,29 @@@
}
break;
case 15:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->rewriteEnabled);
+ this->__isset.rewriteEnabled = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
++ case 16:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->mmNextWriteId);
+ this->__isset.mmNextWriteId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
- case 16:
++ case 17:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->mmWatermarkWriteId);
+ this->__isset.mmWatermarkWriteId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@@ -4759,16 -4744,11 +4772,21 @@@ uint32_t Table::write(::apache::thrift:
xfer += oprot->writeBool(this->temporary);
xfer += oprot->writeFieldEnd();
}
+ if (this->__isset.rewriteEnabled) {
+ xfer += oprot->writeFieldBegin("rewriteEnabled", ::apache::thrift::protocol::T_BOOL, 15);
+ xfer += oprot->writeBool(this->rewriteEnabled);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.mmNextWriteId) {
- xfer += oprot->writeFieldBegin("mmNextWriteId", ::apache::thrift::protocol::T_I64, 15);
++ xfer += oprot->writeFieldBegin("mmNextWriteId", ::apache::thrift::protocol::T_I64, 16);
+ xfer += oprot->writeI64(this->mmNextWriteId);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.mmWatermarkWriteId) {
- xfer += oprot->writeFieldBegin("mmWatermarkWriteId", ::apache::thrift::protocol::T_I64, 16);
++ xfer += oprot->writeFieldBegin("mmWatermarkWriteId", ::apache::thrift::protocol::T_I64, 17);
+ xfer += oprot->writeI64(this->mmWatermarkWriteId);
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
@@@ -4790,8 -4770,7 +4808,9 @@@ void swap(Table &a, Table &b)
swap(a.tableType, b.tableType);
swap(a.privileges, b.privileges);
swap(a.temporary, b.temporary);
+ swap(a.rewriteEnabled, b.rewriteEnabled);
+ swap(a.mmNextWriteId, b.mmNextWriteId);
+ swap(a.mmWatermarkWriteId, b.mmWatermarkWriteId);
swap(a.__isset, b.__isset);
}
@@@ -4810,8 -4789,7 +4829,9 @@@ Table::Table(const Table& other221)
tableType = other221.tableType;
privileges = other221.privileges;
temporary = other221.temporary;
+ rewriteEnabled = other221.rewriteEnabled;
+ mmNextWriteId = other221.mmNextWriteId;
+ mmWatermarkWriteId = other221.mmWatermarkWriteId;
__isset = other221.__isset;
}
Table& Table::operator=(const Table& other222) {
@@@ -4829,8 -4807,7 +4849,9 @@@
tableType = other222.tableType;
privileges = other222.privileges;
temporary = other222.temporary;
+ rewriteEnabled = other222.rewriteEnabled;
+ mmNextWriteId = other222.mmNextWriteId;
+ mmWatermarkWriteId = other222.mmWatermarkWriteId;
__isset = other222.__isset;
return *this;
}
@@@ -4851,8 -4828,7 +4872,9 @@@ void Table::printTo(std::ostream& out)
out << ", " << "tableType=" << to_string(tableType);
out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "<null>"));
out << ", " << "temporary="; (__isset.temporary ? (out << to_string(temporary)) : (out << "<null>"));
+ out << ", " << "rewriteEnabled="; (__isset.rewriteEnabled ? (out << to_string(rewriteEnabled)) : (out << "<null>"));
+ out << ", " << "mmNextWriteId="; (__isset.mmNextWriteId ? (out << to_string(mmNextWriteId)) : (out << "<null>"));
+ out << ", " << "mmWatermarkWriteId="; (__isset.mmWatermarkWriteId ? (out << to_string(mmWatermarkWriteId)) : (out << "<null>"));
out << ")";
}
@@@ -17815,26 -17990,25 +18036,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& other739) {
- dbName = other739.dbName;
- tblName = other739.tblName;
-GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other753) {
- functions = other753.functions;
- __isset = other753.__isset;
++GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other747) {
++ dbName = other747.dbName;
++ tblName = other747.tblName;
}
- GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other740) {
- dbName = other740.dbName;
- tblName = other740.tblName;
-GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other754) {
- functions = other754.functions;
- __isset = other754.__isset;
++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 << ")";
}
@@@ -17905,22 -18101,22 +18126,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& other741) {
- writeId = other741.writeId;
-ClientCapabilities::ClientCapabilities(const ClientCapabilities& other762) {
- values = other762.values;
++GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other749) {
++ writeId = other749.writeId;
}
- GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other742) {
- writeId = other742.writeId;
-ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other763) {
- values = other763.values;
++GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other750) {
++ writeId = other750.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 << ")";
}
@@@ -18052,30 -18228,29 +18273,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& other743) {
- dbName = other743.dbName;
- tblName = other743.tblName;
- writeId = other743.writeId;
- commit = other743.commit;
-GetTableRequest::GetTableRequest(const GetTableRequest& other764) {
- dbName = other764.dbName;
- tblName = other764.tblName;
- capabilities = other764.capabilities;
- __isset = other764.__isset;
++FinalizeWriteIdRequest::FinalizeWriteIdRequest(const FinalizeWriteIdRequest& other751) {
++ dbName = other751.dbName;
++ tblName = other751.tblName;
++ writeId = other751.writeId;
++ commit = other751.commit;
}
- FinalizeWriteIdRequest& FinalizeWriteIdRequest::operator=(const FinalizeWriteIdRequest& other744) {
- dbName = other744.dbName;
- tblName = other744.tblName;
- writeId = other744.writeId;
- commit = other744.commit;
-GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other765) {
- dbName = other765.dbName;
- tblName = other765.tblName;
- capabilities = other765.capabilities;
- __isset = other765.__isset;
++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 << ")";
}
@@@ -18122,22 -18321,22 +18343,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& other745) {
- (void) other745;
-GetTableResult::GetTableResult(const GetTableResult& other766) {
- table = other766.table;
++FinalizeWriteIdResult::FinalizeWriteIdResult(const FinalizeWriteIdResult& other753) {
++ (void) other753;
}
- FinalizeWriteIdResult& FinalizeWriteIdResult::operator=(const FinalizeWriteIdResult& other746) {
- (void) other746;
-GetTableResult& GetTableResult::operator=(const GetTableResult& other767) {
- table = other767.table;
++FinalizeWriteIdResult& FinalizeWriteIdResult::operator=(const FinalizeWriteIdResult& other754) {
++ (void) other754;
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 << ")";
}
@@@ -18246,30 -18463,33 +18467,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& other747) {
- dbName = other747.dbName;
- tblName = other747.tblName;
- writeId = other747.writeId;
-GetTablesRequest::GetTablesRequest(const GetTablesRequest& other774) {
- dbName = other774.dbName;
- tblNames = other774.tblNames;
- capabilities = other774.capabilities;
- __isset = other774.__isset;
++HeartbeatWriteIdRequest::HeartbeatWriteIdRequest(const HeartbeatWriteIdRequest& other755) {
++ dbName = other755.dbName;
++ tblName = other755.tblName;
++ writeId = other755.writeId;
}
- HeartbeatWriteIdRequest& HeartbeatWriteIdRequest::operator=(const HeartbeatWriteIdRequest& other748) {
- dbName = other748.dbName;
- tblName = other748.tblName;
- writeId = other748.writeId;
-GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other775) {
- dbName = other775.dbName;
- tblNames = other775.tblNames;
- capabilities = other775.capabilities;
- __isset = other775.__isset;
++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 << ")";
}
@@@ -18278,947 -18498,11 +18499,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& other749) {
- (void) other749;
++HeartbeatWriteIdResult::HeartbeatWriteIdResult(const HeartbeatWriteIdResult& other757) {
++ (void) other757;
+}
- HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other750) {
- (void) other750;
++HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other758) {
++ (void) other758;
+ 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& other751) {
- dbName = other751.dbName;
- tblName = other751.tblName;
++GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other759) {
++ dbName = other759.dbName;
++ tblName = other759.tblName;
+}
- GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other752) {
- dbName = other752.dbName;
- tblName = other752.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 _size753;
- ::apache::thrift::protocol::TType _etype756;
- xfer += iprot->readListBegin(_etype756, _size753);
- this->ids.resize(_size753);
- uint32_t _i757;
- for (_i757 = 0; _i757 < _size753; ++_i757)
++ 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)
+ {
- xfer += iprot->readI64(this->ids[_i757]);
++ xfer += iprot->readI64(this->ids[_i765]);
+ }
+ 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 _iter758;
- for (_iter758 = this->ids.begin(); _iter758 != this->ids.end(); ++_iter758)
++ std::vector<int64_t> ::const_iterator _iter766;
++ for (_iter766 = this->ids.begin(); _iter766 != this->ids.end(); ++_iter766)
+ {
- xfer += oprot->writeI64((*_iter758));
++ xfer += oprot->writeI64((*_iter766));
+ }
+ 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& other759) {
- lowWatermarkId = other759.lowWatermarkId;
- highWatermarkId = other759.highWatermarkId;
- areIdsValid = other759.areIdsValid;
- ids = other759.ids;
- __isset = other759.__isset;
++GetValidWriteIdsResult::GetValidWriteIdsResult(const GetValidWriteIdsResult& other767) {
++ lowWatermarkId = other767.lowWatermarkId;
++ highWatermarkId = other767.highWatermarkId;
++ areIdsValid = other767.areIdsValid;
++ ids = other767.ids;
++ __isset = other767.__isset;
+}
- GetValidWriteIdsResult& GetValidWriteIdsResult::operator=(const GetValidWriteIdsResult& other760) {
- lowWatermarkId = other760.lowWatermarkId;
- highWatermarkId = other760.highWatermarkId;
- areIdsValid = other760.areIdsValid;
- ids = other760.ids;
- __isset = other760.__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 _size761;
- ::apache::thrift::protocol::TType _etype764;
- xfer += iprot->readListBegin(_etype764, _size761);
- this->functions.resize(_size761);
- uint32_t _i765;
- for (_i765 = 0; _i765 < _size761; ++_i765)
++ 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)
+ {
- xfer += this->functions[_i765].read(iprot);
++ xfer += this->functions[_i773].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 _iter766;
- for (_iter766 = this->functions.begin(); _iter766 != this->functions.end(); ++_iter766)
++ std::vector<Function> ::const_iterator _iter774;
++ for (_iter774 = this->functions.begin(); _iter774 != this->functions.end(); ++_iter774)
+ {
- xfer += (*_iter766).write(oprot);
++ xfer += (*_iter774).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& other767) {
- functions = other767.functions;
- __isset = other767.__isset;
++GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other775) {
++ functions = other775.functions;
++ __isset = other775.__isset;
+}
- GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other768) {
- functions = other768.functions;
- __isset = other768.__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 _size769;
- ::apache::thrift::protocol::TType _etype772;
- xfer += iprot->readListBegin(_etype772, _size769);
- this->values.resize(_size769);
- uint32_t _i773;
- for (_i773 = 0; _i773 < _size769; ++_i773)
++ 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)
+ {
- int32_t ecast774;
- xfer += iprot->readI32(ecast774);
- this->values[_i773] = (ClientCapability::type)ecast774;
++ int32_t ecast782;
++ xfer += iprot->readI32(ecast782);
++ this->values[_i781] = (ClientCapability::type)ecast782;
+ }
+ 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 _iter775;
- for (_iter775 = this->values.begin(); _iter775 != this->values.end(); ++_iter775)
++ std::vector<ClientCapability::type> ::const_iterator _iter783;
++ for (_iter783 = this->values.begin(); _iter783 != this->values.end(); ++_iter783)
+ {
- xfer += oprot->writeI32((int32_t)(*_iter775));
++ xfer += oprot->writeI32((int32_t)(*_iter783));
+ }
+ 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& other776) {
- values = other776.values;
++ClientCapabilities::ClientCapabilities(const ClientCapabilities& other784) {
++ values = other784.values;
+}
- ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other777) {
- values = other777.values;
++ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other785) {
++ values = other785.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& other778) {
- dbName = other778.dbName;
- tblName = other778.tblName;
- capabilities = other778.capabilities;
- __isset = other778.__isset;
++GetTableRequest::GetTableRequest(const GetTableRequest& other786) {
++ dbName = other786.dbName;
++ tblName = other786.tblName;
++ capabilities = other786.capabilities;
++ __isset = other786.__isset;
+}
- GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other779) {
- dbName = other779.dbName;
- tblName = other779.tblName;
- capabilities = other779.capabilities;
- __isset = other779.__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& other780) {
- table = other780.table;
++GetTableResult::GetTableResult(const GetTableResult& other788) {
++ table = other788.table;
+}
- GetTableResult& GetTableResult::operator=(const GetTableResult& other781) {
- table = other781.table;
++GetTableResult& GetTableResult::operator=(const GetTableResult& other789) {
++ table = other789.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 _size782;
- ::apache::thrift::protocol::TType _etype785;
- xfer += iprot->readListBegin(_etype785, _size782);
- this->tblNames.resize(_size782);
- uint32_t _i786;
- for (_i786 = 0; _i786 < _size782; ++_i786)
++ 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)
+ {
- xfer += iprot->readString(this->tblNames[_i786]);
++ xfer += iprot->readString(this->tblNames[_i794]);
+ }
+ 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 _iter787;
- for (_iter787 = this->tblNames.begin(); _iter787 != this->tblNames.end(); ++_iter787)
++ std::vector<std::string> ::const_iterator _iter795;
++ for (_iter795 = this->tblNames.begin(); _iter795 != this->tblNames.end(); ++_iter795)
+ {
- xfer += oprot->writeString((*_iter787));
++ xfer += oprot->writeString((*_iter795));
+ }
+ 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& other788) {
- dbName = other788.dbName;
- tblNames = other788.tblNames;
- capabilities = other788.capabilities;
- __isset = other788.__isset;
++GetTablesRequest::GetTablesRequest(const GetTablesRequest& other796) {
++ dbName = other796.dbName;
++ tblNames = other796.tblNames;
++ capabilities = other796.capabilities;
++ __isset = other796.__isset;
+}
- GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other789) {
- dbName = other789.dbName;
- tblNames = other789.tblNames;
- capabilities = other789.capabilities;
- __isset = other789.__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;
@@@ -19244,14 -18528,14 +19465,14 @@@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tables.clear();
- uint32_t _size790;
- ::apache::thrift::protocol::TType _etype793;
- xfer += iprot->readListBegin(_etype793, _size790);
- this->tables.resize(_size790);
- uint32_t _i794;
- for (_i794 = 0; _i794 < _size790; ++_i794)
- uint32_t _size776;
- ::apache::thrift::protocol::TType _etype779;
- xfer += iprot->readListBegin(_etype779, _size776);
- this->tables.resize(_size776);
- uint32_t _i780;
- for (_i780 = 0; _i780 < _size776; ++_i780)
++ 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)
{
- xfer += this->tables[_i794].read(iprot);
- xfer += this->tables[_i780].read(iprot);
++ xfer += this->tables[_i802].read(iprot);
}
xfer += iprot->readListEnd();
}
@@@ -19282,10 -18566,10 +19503,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 _iter795;
- for (_iter795 = this->tables.begin(); _iter795 != this->tables.end(); ++_iter795)
- std::vector<Table> ::const_iterator _iter781;
- for (_iter781 = this->tables.begin(); _iter781 != this->tables.end(); ++_iter781)
++ std::vector<Table> ::const_iterator _iter803;
++ for (_iter803 = this->tables.begin(); _iter803 != this->tables.end(); ++_iter803)
{
- xfer += (*_iter795).write(oprot);
- xfer += (*_iter781).write(oprot);
++ xfer += (*_iter803).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@@ -19301,11 -18585,11 +19522,11 @@@ void swap(GetTablesResult &a, GetTables
swap(a.tables, b.tables);
}
- GetTablesResult::GetTablesResult(const GetTablesResult& other796) {
- tables = other796.tables;
-GetTablesResult::GetTablesResult(const GetTablesResult& other782) {
- tables = other782.tables;
++GetTablesResult::GetTablesResult(const GetTablesResult& other804) {
++ tables = other804.tables;
}
- GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other797) {
- tables = other797.tables;
-GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other783) {
- tables = other783.tables;
++GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other805) {
++ tables = other805.tables;
return *this;
}
void GetTablesResult::printTo(std::ostream& out) const {
@@@ -19447,19 -18731,19 +19668,19 @@@ void swap(TableMeta &a, TableMeta &b)
swap(a.__isset, b.__isset);
}
- TableMeta::TableMeta(const TableMeta& other798) {
- dbName = other798.dbName;
- tableName = other798.tableName;
- tableType = other798.tableType;
- comments = other798.comments;
- __isset = other798.__isset;
-TableMeta::TableMeta(const TableMeta& other784) {
- dbName = other784.dbName;
- tableName = other784.tableName;
- tableType = other784.tableType;
- comments = other784.comments;
- __isset = other784.__isset;
++TableMeta::TableMeta(const TableMeta& other806) {
++ dbName = other806.dbName;
++ tableName = other806.tableName;
++ tableType = other806.tableType;
++ comments = other806.comments;
++ __isset = other806.__isset;
}
- TableMeta& TableMeta::operator=(const TableMeta& other799) {
- dbName = other799.dbName;
- tableName = other799.tableName;
- tableType = other799.tableType;
- comments = other799.comments;
- __isset = other799.__isset;
-TableMeta& TableMeta::operator=(const TableMeta& other785) {
- dbName = other785.dbName;
- tableName = other785.tableName;
- tableType = other785.tableType;
- comments = other785.comments;
- __isset = other785.__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 {
@@@ -19542,13 -18826,13 +19763,13 @@@ void swap(MetaException &a, MetaExcepti
swap(a.__isset, b.__isset);
}
- MetaException::MetaException(const MetaException& other800) : TException() {
- message = other800.message;
- __isset = other800.__isset;
-MetaException::MetaException(const MetaException& other786) : TException() {
- message = other786.message;
- __isset = other786.__isset;
++MetaException::MetaException(const MetaException& other808) : TException() {
++ message = other808.message;
++ __isset = other808.__isset;
}
- MetaException& MetaException::operator=(const MetaException& other801) {
- message = other801.message;
- __isset = other801.__isset;
-MetaException& MetaException::operator=(const MetaException& other787) {
- message = other787.message;
- __isset = other787.__isset;
++MetaException& MetaException::operator=(const MetaException& other809) {
++ message = other809.message;
++ __isset = other809.__isset;
return *this;
}
void MetaException::printTo(std::ostream& out) const {
@@@ -19639,13 -18923,13 +19860,13 @@@ void swap(UnknownTableException &a, Unk
swap(a.__isset, b.__isset);
}
- UnknownTableException::UnknownTableException(const UnknownTableException& other802) : TException() {
- message = other802.message;
- __isset = other802.__isset;
-UnknownTableException::UnknownTableException(const UnknownTableException& other788) : TException() {
- message = other788.message;
- __isset = other788.__isset;
++UnknownTableException::UnknownTableException(const UnknownTableException& other810) : TException() {
++ message = other810.message;
++ __isset = other810.__isset;
}
- UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other803) {
- message = other803.message;
- __isset = other803.__isset;
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other789) {
- message = other789.message;
- __isset = other789.__isset;
++UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other811) {
++ message = other811.message;
++ __isset = other811.__isset;
return *this;
}
void UnknownTableException::printTo(std::ostream& out) const {
@@@ -19736,13 -19020,13 +19957,13 @@@ void swap(UnknownDBException &a, Unknow
swap(a.__isset, b.__isset);
}
- UnknownDBException::UnknownDBException(const UnknownDBException& other804) : TException() {
- message = other804.message;
- __isset = other804.__isset;
-UnknownDBException::UnknownDBException(const UnknownDBException& other790) : TException() {
- message = other790.message;
- __isset = other790.__isset;
++UnknownDBException::UnknownDBException(const UnknownDBException& other812) : TException() {
++ message = other812.message;
++ __isset = other812.__isset;
}
- UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other805) {
- message = other805.message;
- __isset = other805.__isset;
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other791) {
- message = other791.message;
- __isset = other791.__isset;
++UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other813) {
++ message = other813.message;
++ __isset = other813.__isset;
return *this;
}
void UnknownDBException::printTo(std::ostream& out) const {
@@@ -19833,13 -19117,13 +20054,13 @@@ void swap(AlreadyExistsException &a, Al
swap(a.__isset, b.__isset);
}
- AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other806) : TException() {
- message = other806.message;
- __isset = other806.__isset;
-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other792) : TException() {
- message = other792.message;
- __isset = other792.__isset;
++AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other814) : TException() {
++ message = other814.message;
++ __isset = other814.__isset;
}
- AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other807) {
- message = other807.message;
- __isset = other807.__isset;
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other793) {
- message = other793.message;
- __isset = other793.__isset;
++AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other815) {
++ message = other815.message;
++ __isset = other815.__isset;
return *this;
}
void AlreadyExistsException::printTo(std::ostream& out) const {
@@@ -19930,13 -19214,13 +20151,13 @@@ void swap(InvalidPartitionException &a
swap(a.__isset, b.__isset);
}
- InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other808) : TException() {
- message = other808.message;
- __isset = other808.__isset;
-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other794) : TException() {
- message = other794.message;
- __isset = other794.__isset;
++InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other816) : TException() {
++ message = other816.message;
++ __isset = other816.__isset;
}
- InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other809) {
- message = other809.message;
- __isset = other809.__isset;
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other795) {
- message = other795.message;
- __isset = other795.__isset;
++InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other817) {
++ message = other817.message;
++ __isset = other817.__isset;
return *this;
}
void InvalidPartitionException::printTo(std::ostream& out) const {
@@@ -20027,13 -19311,13 +20248,13 @@@ void swap(UnknownPartitionException &a
swap(a.__isset, b.__isset);
}
- UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other810) : TException() {
- message = other810.message;
- __isset = other810.__isset;
-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other796) : TException() {
- message = other796.message;
- __isset = other796.__isset;
++UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other818) : TException() {
++ message = other818.message;
++ __isset = other818.__isset;
}
- UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other811) {
- message = other811.message;
- __isset = other811.__isset;
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other797) {
- message = other797.message;
- __isset = other797.__isset;
++UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other819) {
++ message = other819.message;
++ __isset = other819.__isset;
return *this;
}
void UnknownPartitionException::printTo(std::ostream& out) const {
@@@ -20124,13 -19408,13 +20345,13 @@@ void swap(InvalidObjectException &a, In
swap(a.__isset, b.__isset);
}
- InvalidObjectException::InvalidObjectException(const InvalidObjectException& other812) : TException() {
- message = other812.message;
- __isset = other812.__isset;
-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other798) : TException() {
- message = other798.message;
- __isset = other798.__isset;
++InvalidObjectException::InvalidObjectException(const InvalidObjectException& other820) : TException() {
++ message = other820.message;
++ __isset = other820.__isset;
}
- InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other813) {
- message = other813.message;
- __isset = other813.__isset;
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other799) {
- message = other799.message;
- __isset = other799.__isset;
++InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other821) {
++ message = other821.message;
++ __isset = other821.__isset;
return *this;
}
void InvalidObjectException::printTo(std::ostream& out) const {
@@@ -20221,13 -19505,13 +20442,13 @@@ void swap(NoSuchObjectException &a, NoS
swap(a.__isset, b.__isset);
}
- NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other814) : TException() {
- message = other814.message;
- __isset = other814.__isset;
-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other800) : TException() {
- message = other800.message;
- __isset = other800.__isset;
++NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other822) : TException() {
++ message = other822.message;
++ __isset = other822.__isset;
}
- NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other815) {
- message = other815.message;
- __isset = other815.__isset;
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other801) {
- message = other801.message;
- __isset = other801.__isset;
++NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other823) {
++ message = other823.message;
++ __isset = other823.__isset;
return *this;
}
void NoSuchObjectException::printTo(std::ostream& out) const {
@@@ -20318,13 -19602,13 +20539,13 @@@ void swap(IndexAlreadyExistsException &
swap(a.__isset, b.__isset);
}
- IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other816) : TException() {
- message = other816.message;
- __isset = other816.__isset;
-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other802) : TException() {
- message = other802.message;
- __isset = other802.__isset;
++IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other824) : TException() {
++ message = other824.message;
++ __isset = other824.__isset;
}
- IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other817) {
- message = other817.message;
- __isset = other817.__isset;
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other803) {
- message = other803.message;
- __isset = other803.__isset;
++IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other825) {
++ message = other825.message;
++ __isset = other825.__isset;
return *this;
}
void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@@ -20415,13 -19699,13 +20636,13 @@@ void swap(InvalidOperationException &a
swap(a.__isset, b.__isset);
}
- InvalidOperationException::InvalidOperationException(const InvalidOperationException& other818) : TException() {
- message = other818.message;
- __isset = other818.__isset;
-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other804) : TException() {
- message = other804.message;
- __isset = other804.__isset;
++InvalidOperationException::InvalidOperationException(const InvalidOperationException& other826) : TException() {
++ message = other826.message;
++ __isset = other826.__isset;
}
- InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other819) {
- message = other819.message;
- __isset = other819.__isset;
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other805) {
- message = other805.message;
- __isset = other805.__isset;
++InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other827) {
++ message = other827.message;
++ __isset = other827.__isset;
return *this;
}
void InvalidOperationException::printTo(std::ostream& out) const {
@@@ -20512,13 -19796,13 +20733,13 @@@ void swap(ConfigValSecurityException &a
swap(a.__isset, b.__isset);
}
- ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other820) : TException() {
- message = other820.message;
- __isset = other820.__isset;
-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other806) : TException() {
- message = other806.message;
- __isset = other806.__isset;
++ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other828) : TException() {
++ message = other828.message;
++ __isset = other828.__isset;
}
- ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other821) {
- message = other821.message;
- __isset = other821.__isset;
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other807) {
- message = other807.message;
- __isset = other807.__isset;
++ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other829) {
++ message = other829.message;
++ __isset = other829.__isset;
return *this;
}
void ConfigValSecurityException::printTo(std::ostream& out) const {
@@@ -20609,13 -19893,13 +20830,13 @@@ void swap(InvalidInputException &a, Inv
swap(a.__isset, b.__isset);
}
- InvalidInputException::InvalidInputException(const InvalidInputException& other822) : TException() {
- message = other822.message;
- __isset = other822.__isset;
-InvalidInputException::InvalidInputException(const InvalidInputException& other808) : TException() {
- message = other808.message;
- __isset = other808.__isset;
++InvalidInputException::InvalidInputException(const InvalidInputException& other830) : TException() {
++ message = other830.message;
++ __isset = other830.__isset;
}
- InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other823) {
- message = other823.message;
- __isset = other823.__isset;
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other809) {
- message = other809.message;
- __isset = other809.__isset;
++InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other831) {
++ message = other831.message;
++ __isset = other831.__isset;
return *this;
}
void InvalidInputException::printTo(std::ostream& out) const {
@@@ -20706,13 -19990,13 +20927,13 @@@ void swap(NoSuchTxnException &a, NoSuch
swap(a.__isset, b.__isset);
}
- NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other824) : TException() {
- message = other824.message;
- __isset = other824.__isset;
-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other810) : TException() {
- message = other810.message;
- __isset = other810.__isset;
++NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other832) : TException() {
++ message = other832.message;
++ __isset = other832.__isset;
}
- NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other825) {
- message = other825.message;
- __isset = other825.__isset;
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other811) {
- message = other811.message;
- __isset = other811.__isset;
++NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other833) {
++ message = other833.message;
++ __isset = other833.__isset;
return *this;
}
void NoSuchTxnException::printTo(std::ostream& out) const {
@@@ -20803,13 -20087,13 +21024,13 @@@ void swap(TxnAbortedException &a, TxnAb
swap(a.__isset, b.__isset);
}
- TxnAbortedException::TxnAbortedException(const TxnAbortedException& other826) : TException() {
- message = other826.message;
- __isset = other826.__isset;
-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other812) : TException() {
- message = other812.message;
- __isset = other812.__isset;
++TxnAbortedException::TxnAbortedException(const TxnAbortedException& other834) : TException() {
++ message = other834.message;
++ __isset = other834.__isset;
}
- TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other827) {
- message = other827.message;
- __isset = other827.__isset;
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other813) {
- message = other813.message;
- __isset = other813.__isset;
++TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other835) {
++ message = other835.message;
++ __isset = other835.__isset;
return *this;
}
void TxnAbortedException::printTo(std::ostream& out) const {
@@@ -20900,13 -20184,13 +21121,13 @@@ void swap(TxnOpenException &a, TxnOpenE
swap(a.__isset, b.__isset);
}
- TxnOpenException::TxnOpenException(const TxnOpenException& other828) : TException() {
- message = other828.message;
- __isset = other828.__isset;
-TxnOpenException::TxnOpenException(const TxnOpenException& other814) : TException() {
- message = other814.message;
- __isset = other814.__isset;
++TxnOpenException::TxnOpenException(const TxnOpenException& other836) : TException() {
++ message = other836.message;
++ __isset = other836.__isset;
}
- TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other829) {
- message = other829.message;
- __isset = other829.__isset;
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other815) {
- message = other815.message;
- __isset = other815.__isset;
++TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other837) {
++ message = other837.message;
++ __isset = other837.__isset;
return *this;
}
void TxnOpenException::printTo(std::ostream& out) const {
@@@ -20997,13 -20281,13 +21218,13 @@@ void swap(NoSuchLockException &a, NoSuc
swap(a.__isset, b.__isset);
}
- NoSuchLockException::NoSuchLockException(const NoSuchLockException& other830) : TException() {
- message = other830.message;
- __isset = other830.__isset;
-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other816) : TException() {
- message = other816.message;
- __isset = other816.__isset;
++NoSuchLockException::NoSuchLockException(const NoSuchLockException& other838) : TException() {
++ message = other838.message;
++ __isset = other838.__isset;
}
- NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other831) {
- message = other831.message;
- __isset = other831.__isset;
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other817) {
- message = other817.message;
- __isset = other817.__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/748c1bd2/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index ee08c76,4d5da71..b954a12
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@@ -2077,7 -2062,7 +2079,7 @@@ inline std::ostream& operator<<(std::os
}
typedef struct _Table__isset {
- _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true), mmNextWriteId(false), mmWatermarkWriteId(false) {}
- _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true), rewriteEnabled(false) {}
++ _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true), rewriteEnabled(false), mmNextWriteId(false), mmWatermarkWriteId(false) {}
bool tableName :1;
bool dbName :1;
bool owner :1;
@@@ -2092,8 -2077,7 +2094,9 @@@
bool tableType :1;
bool privileges :1;
bool temporary :1;
+ bool rewriteEnabled :1;
+ bool mmNextWriteId :1;
+ bool mmWatermarkWriteId :1;
} _Table__isset;
class Table {
@@@ -2101,7 -2085,7 +2104,7 @@@
Table(const Table&);
Table& operator=(const Table&);
- Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false), mmNextWriteId(0), mmWatermarkWriteId(0) {
- Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false), rewriteEnabled(0) {
++ Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false), rewriteEnabled(0), mmNextWriteId(0), mmWatermarkWriteId(0) {
}
virtual ~Table() throw();
@@@ -2119,8 -2103,7 +2122,9 @@@
std::string tableType;
PrincipalPrivilegeSet privileges;
bool temporary;
+ bool rewriteEnabled;
+ int64_t mmNextWriteId;
+ int64_t mmWatermarkWriteId;
_Table__isset __isset;
@@@ -2152,10 -2135,8 +2156,12 @@@
void __set_temporary(const bool val);
+ void __set_rewriteEnabled(const bool val);
+
+ void __set_mmNextWriteId(const int64_t val);
+
+ void __set_mmWatermarkWriteId(const int64_t val);
+
bool operator == (const Table & rhs) const
{
if (!(tableName == rhs.tableName))
@@@ -2190,14 -2171,10 +2196,18 @@@
return false;
else if (__isset.temporary && !(temporary == rhs.temporary))
return false;
+ if (__isset.rewriteEnabled != rhs.__isset.rewriteEnabled)
+ return false;
+ else if (__isset.rewriteEnabled && !(rewriteEnabled == rhs.rewriteEnabled))
+ return false;
+ if (__isset.mmNextWriteId != rhs.__isset.mmNextWriteId)
+ return false;
+ else if (__isset.mmNextWriteId && !(mmNextWriteId == rhs.mmNextWriteId))
+ return false;
+ if (__isset.mmWatermarkWriteId != rhs.__isset.mmWatermarkWriteId)
+ return false;
+ else if (__isset.mmWatermarkWriteId && !(mmWatermarkWriteId == rhs.mmWatermarkWriteId))
+ return false;
return true;
}
bool operator != (const Table &rhs) const {
http://git-wip-us.apache.org/repos/asf/hive/blob/748c1bd2/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
index 81534fe,81534fe..d7ab0cf
--- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
@@@ -354,13 -354,13 +354,13 @@@ public class ClientCapabilities impleme
case 1: // VALUES
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
-- org.apache.thrift.protocol.TList _list650 = iprot.readListBegin();
-- struct.values = new ArrayList<ClientCapability>(_list650.size);
-- ClientCapability _elem651;
-- for (int _i652 = 0; _i652 < _list650.size; ++_i652)
++ org.apache.thrift.protocol.TList _list658 = iprot.readListBegin();
++ struct.values = new ArrayList<ClientCapability>(_list658.size);
++ ClientCapability _elem659;
++ for (int _i660 = 0; _i660 < _list658.size; ++_i660)
{
-- _elem651 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
-- struct.values.add(_elem651);
++ _elem659 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
++ struct.values.add(_elem659);
}
iprot.readListEnd();
}
@@@ -386,9 -386,9 +386,9 @@@
oprot.writeFieldBegin(VALUES_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.values.size()));
-- for (ClientCapability _iter653 : struct.values)
++ for (ClientCapability _iter661 : struct.values)
{
-- oprot.writeI32(_iter653.getValue());
++ oprot.writeI32(_iter661.getValue());
}
oprot.writeListEnd();
}
@@@ -413,9 -413,9 +413,9 @@@
TTupleProtocol oprot = (TTupleProtocol) prot;
{
oprot.writeI32(struct.values.size());
-- for (ClientCapability _iter654 : struct.values)
++ for (ClientCapability _iter662 : struct.values)
{
-- oprot.writeI32(_iter654.getValue());
++ oprot.writeI32(_iter662.getValue());
}
}
}
@@@ -424,13 -424,13 +424,13 @@@
public void read(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities struct) throws org.apache.thrift.TException {
TTupleProtocol iprot = (TTupleProtocol) prot;
{
-- org.apache.thrift.protocol.TList _list655 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
-- struct.values = new ArrayList<ClientCapability>(_list655.size);
-- ClientCapability _elem656;
-- for (int _i657 = 0; _i657 < _list655.size; ++_i657)
++ org.apache.thrift.protocol.TList _list663 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
++ struct.values = new ArrayList<ClientCapability>(_list663.size);
++ ClientCapability _elem664;
++ for (int _i665 = 0; _i665 < _list663.size; ++_i665)
{
-- _elem656 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
-- struct.values.add(_elem656);
++ _elem664 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
++ struct.values.add(_elem664);
}
}
struct.setValuesIsSet(true);
http://git-wip-us.apache.org/repos/asf/hive/blob/748c1bd2/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
index 49a1be2,49a1be2..2551870
--- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
@@@ -346,14 -346,14 +346,14 @@@ public class GetAllFunctionsResponse im
case 1: // FUNCTIONS
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
-- org.apache.thrift.protocol.TList _list642 = iprot.readListBegin();
-- struct.functions = new ArrayList<Function>(_list642.size);
-- Function _elem643;
-- for (int _i644 = 0; _i644 < _list642.size; ++_i644)
++ org.apache.thrift.protocol.TList _list650 = iprot.readListBegin();
++ struct.functions = new ArrayList<Function>(_list650.size);
++ Function _elem651;
++ for (int _i652 = 0; _i652 < _list650.size; ++_i652)
{
-- _elem643 = new Function();
-- _elem643.read(iprot);
-- struct.functions.add(_elem643);
++ _elem651 = new Function();
++ _elem651.read(iprot);
++ struct.functions.add(_elem651);
}
iprot.readListEnd();
}
@@@ -380,9 -380,9 +380,9 @@@
oprot.writeFieldBegin(FUNCTIONS_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.functions.size()));
-- for (Function _iter645 : struct.functions)
++ for (Function _iter653 : struct.functions)
{
-- _iter645.write(oprot);
++ _iter653.write(oprot);
}
oprot.writeListEnd();
}
@@@ -414,9 -414,9 +414,9 @@@
if (struct.isSetFunctions()) {
{
oprot.writeI32(struct.functions.size());
-- for (Function _iter646 : struct.functions)
++ for (Function _iter654 : struct.functions)
{
-- _iter646.write(oprot);
++ _iter654.write(oprot);
}
}
}
@@@ -428,14 -428,14 +428,14 @@@
BitSet incoming = iprot.readBitSet(1);
if (incoming.get(0)) {
{
-- org.apache.thrift.protocol.TList _list647 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-- struct.functions = new ArrayList<Function>(_list647.size);
-- Function _elem648;
-- for (int _i649 = 0; _i649 < _list647.size; ++_i649)
++ org.apache.thrift.protocol.TList _list655 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
++ struct.functions = new ArrayList<Function>(_list655.size);
++ Function _elem656;
++ for (int _i657 = 0; _i657 < _list655.size; ++_i657)
{
-- _elem648 = new Function();
-- _elem648.read(iprot);
-- struct.functions.add(_elem648);
++ _elem656 = new Function();
++ _elem656.read(iprot);
++ struct.functions.add(_elem656);
}
}
struct.setFunctionsIsSet(true);
http://git-wip-us.apache.org/repos/asf/hive/blob/748c1bd2/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java
index 225fda9,225fda9..00ee22b
--- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetTablesRequest.java
@@@ -525,13 -525,13 +525,13 @@@ public class GetTablesRequest implement
case 2: // TBL_NAMES
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
-- org.apache.thrift.protocol.TList _list658 = iprot.readListBegin();
-- struct.tblNames = new ArrayList<String>(_list658.size);
-- String _elem659;
-- for (int _i660 = 0; _i660 < _list658.size; ++_i660)
++ org.apache.thrift.protocol.TList _list666 = iprot.readListBegin();
++ struct.tblNames = new ArrayList<String>(_list666.size);
++ String _elem667;
++ for (int _i668 = 0; _i668 < _list666.size; ++_i668)
{
-- _elem659 = iprot.readString();
-- struct.tblNames.add(_elem659);
++ _elem667 = iprot.readString();
++ struct.tblNames.add(_elem667);
}
iprot.readListEnd();
}
@@@ -572,9 -572,9 +572,9 @@@
oprot.writeFieldBegin(TBL_NAMES_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tblNames.size()));
-- for (String _iter661 : struct.tblNames)
++ for (String _iter669 : struct.tblNames)
{
-- oprot.writeString(_iter661);
++ oprot.writeString(_iter669);
}
oprot.writeListEnd();
}
@@@ -617,9 -617,9 +617,9 @@@
if (struct.isSetTblNames()) {
{
oprot.writeI32(struct.tblNames.size());
-- for (String _iter662 : struct.tblNames)
++ for (String _iter670 : struct.tblNames)
{
-- oprot.writeString(_iter662);
++ oprot.writeString(_iter670);
}
}
}
@@@ -636,13 -636,13 +636,13 @@@
BitSet incoming = iprot.readBitSet(2);
if (incoming.get(0)) {
{
-- org.apache.thrift.protocol.TList _list663 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-- struct.tblNames = new ArrayList<String>(_list663.size);
-- String _elem664;
-- for (int _i665 = 0; _i665 < _list663.size; ++_i665)
++ org.apache.thrift.protocol.TList _list671 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
++ struct.tblNames = new ArrayList<String>(_list671.size);
++ String _elem672;
++ for (int _i673 = 0; _i673 < _list671.size; ++_i673)
{
-- _elem664 = iprot.readString();
-- struct.tblNames.add(_elem664);
++ _elem672 = iprot.readString();
++ struct.tblNames.add(_elem672);
}
}
struct.setTblNamesIsSet(true);