You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by br...@apache.org on 2013/09/27 19:41:55 UTC
svn commit: r1526996 [5/29] - in /hive/branches/maven: ./
beeline/src/java/org/apache/hive/beeline/
beeline/src/test/org/apache/hive/beeline/src/test/ bin/ bin/ext/
common/src/java/org/apache/hadoop/hive/conf/ conf/
contrib/src/test/results/clientposit...
Modified: hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
URL: http://svn.apache.org/viewvc/hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1526996&r1=1526995&r2=1526996&view=diff
==============================================================================
--- hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Fri Sep 27 17:41:42 2013
@@ -61,6 +61,7 @@ class ThriftHiveMetastoreIf : virtual pu
virtual void get_partitions_ps_with_auth(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names) = 0;
virtual void get_partition_names_ps(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts) = 0;
virtual void get_partitions_by_filter(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts) = 0;
+ virtual void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) = 0;
virtual void get_partitions_by_names(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names) = 0;
virtual void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) = 0;
virtual void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts) = 0;
@@ -269,6 +270,9 @@ class ThriftHiveMetastoreNull : virtual
void get_partitions_by_filter(std::vector<Partition> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* filter */, const int16_t /* max_parts */) {
return;
}
+ void get_partitions_by_expr(PartitionsByExprResult& /* _return */, const PartitionsByExprRequest& /* req */) {
+ return;
+ }
void get_partitions_by_names(std::vector<Partition> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* names */) {
return;
}
@@ -6912,6 +6916,134 @@ class ThriftHiveMetastore_get_partitions
};
+typedef struct _ThriftHiveMetastore_get_partitions_by_expr_args__isset {
+ _ThriftHiveMetastore_get_partitions_by_expr_args__isset() : req(false) {}
+ bool req;
+} _ThriftHiveMetastore_get_partitions_by_expr_args__isset;
+
+class ThriftHiveMetastore_get_partitions_by_expr_args {
+ public:
+
+ ThriftHiveMetastore_get_partitions_by_expr_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_partitions_by_expr_args() throw() {}
+
+ PartitionsByExprRequest req;
+
+ _ThriftHiveMetastore_get_partitions_by_expr_args__isset __isset;
+
+ void __set_req(const PartitionsByExprRequest& val) {
+ req = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_get_partitions_by_expr_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_partitions_by_expr_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_partitions_by_expr_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_partitions_by_expr_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_partitions_by_expr_pargs() throw() {}
+
+ const PartitionsByExprRequest* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partitions_by_expr_result__isset {
+ _ThriftHiveMetastore_get_partitions_by_expr_result__isset() : success(false), o1(false), o2(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+} _ThriftHiveMetastore_get_partitions_by_expr_result__isset;
+
+class ThriftHiveMetastore_get_partitions_by_expr_result {
+ public:
+
+ ThriftHiveMetastore_get_partitions_by_expr_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_partitions_by_expr_result() throw() {}
+
+ PartitionsByExprResult success;
+ MetaException o1;
+ NoSuchObjectException o2;
+
+ _ThriftHiveMetastore_get_partitions_by_expr_result__isset __isset;
+
+ void __set_success(const PartitionsByExprResult& val) {
+ success = val;
+ }
+
+ void __set_o1(const MetaException& val) {
+ o1 = val;
+ }
+
+ void __set_o2(const NoSuchObjectException& val) {
+ o2 = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_get_partitions_by_expr_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_partitions_by_expr_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_partitions_by_expr_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partitions_by_expr_presult__isset {
+ _ThriftHiveMetastore_get_partitions_by_expr_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+} _ThriftHiveMetastore_get_partitions_by_expr_presult__isset;
+
+class ThriftHiveMetastore_get_partitions_by_expr_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_partitions_by_expr_presult() throw() {}
+
+ PartitionsByExprResult* success;
+ MetaException o1;
+ NoSuchObjectException o2;
+
+ _ThriftHiveMetastore_get_partitions_by_expr_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
typedef struct _ThriftHiveMetastore_get_partitions_by_names_args__isset {
_ThriftHiveMetastore_get_partitions_by_names_args__isset() : db_name(false), tbl_name(false), names(false) {}
bool db_name;
@@ -12244,6 +12376,9 @@ class ThriftHiveMetastoreClient : virtua
void get_partitions_by_filter(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
void send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
void recv_get_partitions_by_filter(std::vector<Partition> & _return);
+ void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req);
+ void send_get_partitions_by_expr(const PartitionsByExprRequest& req);
+ void recv_get_partitions_by_expr(PartitionsByExprResult& _return);
void get_partitions_by_names(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names);
void send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names);
void recv_get_partitions_by_names(std::vector<Partition> & _return);
@@ -12410,6 +12545,7 @@ class ThriftHiveMetastoreProcessor : pub
void process_get_partitions_ps_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_get_partition_names_ps(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_get_partitions_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_get_partitions_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_get_partitions_by_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_alter_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_alter_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -12496,6 +12632,7 @@ class ThriftHiveMetastoreProcessor : pub
processMap_["get_partitions_ps_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partitions_ps_with_auth;
processMap_["get_partition_names_ps"] = &ThriftHiveMetastoreProcessor::process_get_partition_names_ps;
processMap_["get_partitions_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_filter;
+ processMap_["get_partitions_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_expr;
processMap_["get_partitions_by_names"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_names;
processMap_["alter_partition"] = &ThriftHiveMetastoreProcessor::process_alter_partition;
processMap_["alter_partitions"] = &ThriftHiveMetastoreProcessor::process_alter_partitions;
@@ -13000,6 +13137,16 @@ class ThriftHiveMetastoreMultiface : vir
return;
}
+ void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->get_partitions_by_expr(_return, req);
+ }
+ ifaces_[i]->get_partitions_by_expr(_return, req);
+ return;
+ }
+
void get_partitions_by_names(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names) {
size_t sz = ifaces_.size();
size_t i = 0;
Modified: hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
URL: http://svn.apache.org/viewvc/hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1526996&r1=1526995&r2=1526996&view=diff
==============================================================================
--- hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original)
+++ hive/branches/maven/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Fri Sep 27 17:41:42 2013
@@ -247,6 +247,11 @@ class ThriftHiveMetastoreHandler : virtu
printf("get_partitions_by_filter\n");
}
+ void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) {
+ // Your implementation goes here
+ printf("get_partitions_by_expr\n");
+ }
+
void get_partitions_by_names(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names) {
// Your implementation goes here
printf("get_partitions_by_names\n");
Modified: hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
URL: http://svn.apache.org/viewvc/hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1526996&r1=1526995&r2=1526996&view=diff
==============================================================================
--- hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original)
+++ hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Fri Sep 27 17:41:42 2013
@@ -3719,6 +3719,232 @@ void swap(EnvironmentContext &a, Environ
swap(a.__isset, b.__isset);
}
+const char* PartitionsByExprResult::ascii_fingerprint = "1B91CF0D2FC339DC29ABBD79CC9700E4";
+const uint8_t PartitionsByExprResult::binary_fingerprint[16] = {0x1B,0x91,0xCF,0x0D,0x2F,0xC3,0x39,0xDC,0x29,0xAB,0xBD,0x79,0xCC,0x97,0x00,0xE4};
+
+uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* 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_partitions = false;
+ bool isset_hasUnknownPartitions = 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_SET) {
+ {
+ this->partitions.clear();
+ uint32_t _size201;
+ ::apache::thrift::protocol::TType _etype204;
+ xfer += iprot->readSetBegin(_etype204, _size201);
+ uint32_t _i205;
+ for (_i205 = 0; _i205 < _size201; ++_i205)
+ {
+ Partition _elem206;
+ xfer += _elem206.read(iprot);
+ this->partitions.insert(_elem206);
+ }
+ xfer += iprot->readSetEnd();
+ }
+ isset_partitions = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->hasUnknownPartitions);
+ isset_hasUnknownPartitions = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_partitions)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_hasUnknownPartitions)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionsByExprResult");
+
+ xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_SET, 1);
+ {
+ xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
+ std::set<Partition> ::const_iterator _iter207;
+ for (_iter207 = this->partitions.begin(); _iter207 != this->partitions.end(); ++_iter207)
+ {
+ xfer += (*_iter207).write(oprot);
+ }
+ xfer += oprot->writeSetEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("hasUnknownPartitions", ::apache::thrift::protocol::T_BOOL, 2);
+ xfer += oprot->writeBool(this->hasUnknownPartitions);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) {
+ using ::std::swap;
+ swap(a.partitions, b.partitions);
+ swap(a.hasUnknownPartitions, b.hasUnknownPartitions);
+}
+
+const char* PartitionsByExprRequest::ascii_fingerprint = "835944417A026FE6ABD0DF5A35BF52C5";
+const uint8_t PartitionsByExprRequest::binary_fingerprint[16] = {0x83,0x59,0x44,0x41,0x7A,0x02,0x6F,0xE6,0xAB,0xD0,0xDF,0x5A,0x35,0xBF,0x52,0xC5};
+
+uint32_t PartitionsByExprRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_dbName = false;
+ bool isset_tblName = false;
+ bool isset_expr = 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_STRING) {
+ xfer += iprot->readBinary(this->expr);
+ isset_expr = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->defaultPartitionName);
+ this->__isset.defaultPartitionName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_I16) {
+ xfer += iprot->readI16(this->maxParts);
+ this->__isset.maxParts = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_dbName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_tblName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_expr)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t PartitionsByExprRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionsByExprRequest");
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tblName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("expr", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeBinary(this->expr);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.defaultPartitionName) {
+ xfer += oprot->writeFieldBegin("defaultPartitionName", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->defaultPartitionName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.maxParts) {
+ xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I16, 5);
+ xfer += oprot->writeI16(this->maxParts);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
+ swap(a.expr, b.expr);
+ swap(a.defaultPartitionName, b.defaultPartitionName);
+ swap(a.maxParts, b.maxParts);
+ swap(a.__isset, b.__isset);
+}
+
const char* MetaException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
const uint8_t MetaException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
Modified: hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
URL: http://svn.apache.org/viewvc/hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1526996&r1=1526995&r2=1526996&view=diff
==============================================================================
--- hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original)
+++ hive/branches/maven/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Fri Sep 27 17:41:42 2013
@@ -1972,6 +1972,128 @@ class EnvironmentContext {
void swap(EnvironmentContext &a, EnvironmentContext &b);
+
+class PartitionsByExprResult {
+ public:
+
+ static const char* ascii_fingerprint; // = "1B91CF0D2FC339DC29ABBD79CC9700E4";
+ static const uint8_t binary_fingerprint[16]; // = {0x1B,0x91,0xCF,0x0D,0x2F,0xC3,0x39,0xDC,0x29,0xAB,0xBD,0x79,0xCC,0x97,0x00,0xE4};
+
+ PartitionsByExprResult() : hasUnknownPartitions(0) {
+ }
+
+ virtual ~PartitionsByExprResult() throw() {}
+
+ std::set<Partition> partitions;
+ bool hasUnknownPartitions;
+
+ void __set_partitions(const std::set<Partition> & val) {
+ partitions = val;
+ }
+
+ void __set_hasUnknownPartitions(const bool val) {
+ hasUnknownPartitions = val;
+ }
+
+ bool operator == (const PartitionsByExprResult & rhs) const
+ {
+ if (!(partitions == rhs.partitions))
+ return false;
+ if (!(hasUnknownPartitions == rhs.hasUnknownPartitions))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionsByExprResult &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionsByExprResult & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionsByExprResult &a, PartitionsByExprResult &b);
+
+typedef struct _PartitionsByExprRequest__isset {
+ _PartitionsByExprRequest__isset() : defaultPartitionName(false), maxParts(true) {}
+ bool defaultPartitionName;
+ bool maxParts;
+} _PartitionsByExprRequest__isset;
+
+class PartitionsByExprRequest {
+ public:
+
+ static const char* ascii_fingerprint; // = "835944417A026FE6ABD0DF5A35BF52C5";
+ static const uint8_t binary_fingerprint[16]; // = {0x83,0x59,0x44,0x41,0x7A,0x02,0x6F,0xE6,0xAB,0xD0,0xDF,0x5A,0x35,0xBF,0x52,0xC5};
+
+ PartitionsByExprRequest() : dbName(), tblName(), expr(), defaultPartitionName(), maxParts(-1) {
+ }
+
+ virtual ~PartitionsByExprRequest() throw() {}
+
+ std::string dbName;
+ std::string tblName;
+ std::string expr;
+ std::string defaultPartitionName;
+ int16_t maxParts;
+
+ _PartitionsByExprRequest__isset __isset;
+
+ void __set_dbName(const std::string& val) {
+ dbName = val;
+ }
+
+ void __set_tblName(const std::string& val) {
+ tblName = val;
+ }
+
+ void __set_expr(const std::string& val) {
+ expr = val;
+ }
+
+ void __set_defaultPartitionName(const std::string& val) {
+ defaultPartitionName = val;
+ __isset.defaultPartitionName = true;
+ }
+
+ void __set_maxParts(const int16_t val) {
+ maxParts = val;
+ __isset.maxParts = true;
+ }
+
+ bool operator == (const PartitionsByExprRequest & rhs) const
+ {
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (!(tblName == rhs.tblName))
+ return false;
+ if (!(expr == rhs.expr))
+ return false;
+ if (__isset.defaultPartitionName != rhs.__isset.defaultPartitionName)
+ return false;
+ else if (__isset.defaultPartitionName && !(defaultPartitionName == rhs.defaultPartitionName))
+ return false;
+ if (__isset.maxParts != rhs.__isset.maxParts)
+ return false;
+ else if (__isset.maxParts && !(maxParts == rhs.maxParts))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionsByExprRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionsByExprRequest & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b);
+
typedef struct _MetaException__isset {
_MetaException__isset() : message(false) {}
bool message;