You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by cw...@apache.org on 2011/06/20 11:28:56 UTC
svn commit: r1137561 [1/5] - in /hive/trunk/metastore: if/
src/gen/thrift/gen-cpp/
src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/
src/gen/thrift/gen-php/hive_metastore/
src/gen/thrift/gen-py/hive_metastore/ src/gen/thrift/gen-rb/ src...
Author: cws
Date: Mon Jun 20 09:28:55 2011
New Revision: 1137561
URL: http://svn.apache.org/viewvc?rev=1137561&view=rev
Log:
HIVE-2215. Add api for marking / querying set of partitions for events (Ashutosh Chauhan via cws)
Added:
hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InvalidPartitionException.java (with props)
hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionEventType.java (with props)
hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/UnknownPartitionException.java (with props)
hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/events/LoadPartitionDoneEvent.java (with props)
hive/trunk/metastore/src/model/org/apache/hadoop/hive/metastore/model/MPartitionEvent.java (with props)
hive/trunk/metastore/src/test/org/apache/hadoop/hive/metastore/TestMarkPartition.java (with props)
hive/trunk/metastore/src/test/org/apache/hadoop/hive/metastore/TestMarkPartitionRemote.java (with props)
Modified:
hive/trunk/metastore/if/hive_metastore.thrift
hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java
hive/trunk/metastore/src/gen/thrift/gen-php/hive_metastore/ThriftHiveMetastore.php
hive/trunk/metastore/src/gen/thrift/gen-php/hive_metastore/hive_metastore_types.php
hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote
hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
hive/trunk/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb
hive/trunk/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb
hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java
hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java
hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java
hive/trunk/metastore/src/model/package.jdo
hive/trunk/metastore/src/test/org/apache/hadoop/hive/metastore/DummyListener.java
hive/trunk/metastore/src/test/org/apache/hadoop/hive/metastore/TestMetaStoreEventListener.java
Modified: hive/trunk/metastore/if/hive_metastore.thrift
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/if/hive_metastore.thrift?rev=1137561&r1=1137560&r2=1137561&view=diff
==============================================================================
--- hive/trunk/metastore/if/hive_metastore.thrift (original)
+++ hive/trunk/metastore/if/hive_metastore.thrift Mon Jun 20 09:28:55 2011
@@ -43,6 +43,10 @@ enum PrincipalType {
GROUP = 3,
}
+enum PartitionEventType {
+ LOAD_DONE = 1,
+}
+
struct HiveObjectRef{
1: HiveObjectType objectType,
2: string dbName,
@@ -182,6 +186,14 @@ exception AlreadyExistsException {
1: string message
}
+exception InvalidPartitionException {
+ 1: string message
+}
+
+exception UnknownPartitionException {
+ 1: string message
+}
+
exception InvalidObjectException {
1: string message
}
@@ -331,6 +343,15 @@ service ThriftHiveMetastore extends fb30
map<string, string> partition_name_to_spec(1: string part_name)
throws(1: MetaException o1)
+ void markPartitionForEvent(1:string db_name, 2:string tbl_name, 3:map<string,string> part_vals,
+ 4:PartitionEventType eventType) throws (1: MetaException o1, 2: NoSuchObjectException o2,
+ 3: UnknownDBException o3, 4: UnknownTableException o4, 5: UnknownPartitionException o5,
+ 6: InvalidPartitionException o6)
+ bool isPartitionMarkedForEvent(1:string db_name, 2:string tbl_name, 3:map<string,string> part_vals,
+ 4: PartitionEventType eventType) throws (1: MetaException o1, 2:NoSuchObjectException o2,
+ 3: UnknownDBException o3, 4: UnknownTableException o4, 5: UnknownPartitionException o5,
+ 6: InvalidPartitionException o6)
+
//index
Index add_index(1:Index new_index, 2: Table index_table)
throws(1:InvalidObjectException o1, 2:AlreadyExistsException o2, 3:MetaException o3)
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp?rev=1137561&r1=1137560&r2=1137561&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp Mon Jun 20 09:28:55 2011
@@ -9299,6 +9299,696 @@ uint32_t ThriftHiveMetastore_partition_n
return xfer;
}
+uint32_t ThriftHiveMetastore_markPartitionForEvent_args::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;
+
+
+ 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->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->part_vals.clear();
+ uint32_t _size445;
+ ::apache::thrift::protocol::TType _ktype446;
+ ::apache::thrift::protocol::TType _vtype447;
+ iprot->readMapBegin(_ktype446, _vtype447, _size445);
+ uint32_t _i449;
+ for (_i449 = 0; _i449 < _size445; ++_i449)
+ {
+ std::string _key450;
+ xfer += iprot->readString(_key450);
+ std::string& _val451 = this->part_vals[_key450];
+ xfer += iprot->readString(_val451);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.part_vals = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast452;
+ xfer += iprot->readI32(ecast452);
+ this->eventType = (PartitionEventType::type)ecast452;
+ this->__isset.eventType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_markPartitionForEvent_args");
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->part_vals.size());
+ std::map<std::string, std::string> ::const_iterator _iter453;
+ for (_iter453 = this->part_vals.begin(); _iter453 != this->part_vals.end(); ++_iter453)
+ {
+ xfer += oprot->writeString(_iter453->first);
+ xfer += oprot->writeString(_iter453->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4);
+ xfer += oprot->writeI32((int32_t)this->eventType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_markPartitionForEvent_pargs");
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, (*(this->part_vals)).size());
+ std::map<std::string, std::string> ::const_iterator _iter454;
+ for (_iter454 = (*(this->part_vals)).begin(); _iter454 != (*(this->part_vals)).end(); ++_iter454)
+ {
+ xfer += oprot->writeString(_iter454->first);
+ xfer += oprot->writeString(_iter454->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4);
+ xfer += oprot->writeI32((int32_t)(*(this->eventType)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_markPartitionForEvent_result::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;
+
+
+ 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->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o5.read(iprot);
+ this->__isset.o5 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o6.read(iprot);
+ this->__isset.o6 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_markPartitionForEvent_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_markPartitionForEvent_result");
+
+ if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o3) {
+ xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->o3.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o4) {
+ xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->o4.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o5) {
+ xfer += oprot->writeFieldBegin("o5", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->o5.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o6) {
+ xfer += oprot->writeFieldBegin("o6", ::apache::thrift::protocol::T_STRUCT, 6);
+ xfer += this->o6.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_markPartitionForEvent_presult::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;
+
+
+ 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->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o5.read(iprot);
+ this->__isset.o5 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o6.read(iprot);
+ this->__isset.o6 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::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;
+
+
+ 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->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->part_vals.clear();
+ uint32_t _size455;
+ ::apache::thrift::protocol::TType _ktype456;
+ ::apache::thrift::protocol::TType _vtype457;
+ iprot->readMapBegin(_ktype456, _vtype457, _size455);
+ uint32_t _i459;
+ for (_i459 = 0; _i459 < _size455; ++_i459)
+ {
+ std::string _key460;
+ xfer += iprot->readString(_key460);
+ std::string& _val461 = this->part_vals[_key460];
+ xfer += iprot->readString(_val461);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.part_vals = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast462;
+ xfer += iprot->readI32(ecast462);
+ this->eventType = (PartitionEventType::type)ecast462;
+ this->__isset.eventType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_isPartitionMarkedForEvent_args");
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->part_vals.size());
+ std::map<std::string, std::string> ::const_iterator _iter463;
+ for (_iter463 = this->part_vals.begin(); _iter463 != this->part_vals.end(); ++_iter463)
+ {
+ xfer += oprot->writeString(_iter463->first);
+ xfer += oprot->writeString(_iter463->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4);
+ xfer += oprot->writeI32((int32_t)this->eventType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_isPartitionMarkedForEvent_pargs");
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, (*(this->part_vals)).size());
+ std::map<std::string, std::string> ::const_iterator _iter464;
+ for (_iter464 = (*(this->part_vals)).begin(); _iter464 != (*(this->part_vals)).end(); ++_iter464)
+ {
+ xfer += oprot->writeString(_iter464->first);
+ xfer += oprot->writeString(_iter464->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_I32, 4);
+ xfer += oprot->writeI32((int32_t)(*(this->eventType)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_result::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;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o5.read(iprot);
+ this->__isset.o5 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o6.read(iprot);
+ this->__isset.o6 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_isPartitionMarkedForEvent_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o3) {
+ xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->o3.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o4) {
+ xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->o4.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o5) {
+ xfer += oprot->writeFieldBegin("o5", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->o5.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o6) {
+ xfer += oprot->writeFieldBegin("o6", ::apache::thrift::protocol::T_STRUCT, 6);
+ xfer += this->o6.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_presult::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;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o5.read(iprot);
+ this->__isset.o5 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o6.read(iprot);
+ this->__isset.o6 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
uint32_t ThriftHiveMetastore_add_index_args::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t xfer = 0;
@@ -10331,14 +11021,14 @@ uint32_t ThriftHiveMetastore_get_indexes
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size445;
- ::apache::thrift::protocol::TType _etype448;
- iprot->readListBegin(_etype448, _size445);
- this->success.resize(_size445);
- uint32_t _i449;
- for (_i449 = 0; _i449 < _size445; ++_i449)
+ uint32_t _size465;
+ ::apache::thrift::protocol::TType _etype468;
+ iprot->readListBegin(_etype468, _size465);
+ this->success.resize(_size465);
+ uint32_t _i469;
+ for (_i469 = 0; _i469 < _size465; ++_i469)
{
- xfer += this->success[_i449].read(iprot);
+ xfer += this->success[_i469].read(iprot);
}
iprot->readListEnd();
}
@@ -10385,10 +11075,10 @@ uint32_t ThriftHiveMetastore_get_indexes
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
- std::vector<Index> ::const_iterator _iter450;
- for (_iter450 = this->success.begin(); _iter450 != this->success.end(); ++_iter450)
+ std::vector<Index> ::const_iterator _iter470;
+ for (_iter470 = this->success.begin(); _iter470 != this->success.end(); ++_iter470)
{
- xfer += (*_iter450).write(oprot);
+ xfer += (*_iter470).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10431,14 +11121,14 @@ uint32_t ThriftHiveMetastore_get_indexes
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size451;
- ::apache::thrift::protocol::TType _etype454;
- iprot->readListBegin(_etype454, _size451);
- (*(this->success)).resize(_size451);
- uint32_t _i455;
- for (_i455 = 0; _i455 < _size451; ++_i455)
+ uint32_t _size471;
+ ::apache::thrift::protocol::TType _etype474;
+ iprot->readListBegin(_etype474, _size471);
+ (*(this->success)).resize(_size471);
+ uint32_t _i475;
+ for (_i475 = 0; _i475 < _size471; ++_i475)
{
- xfer += (*(this->success))[_i455].read(iprot);
+ xfer += (*(this->success))[_i475].read(iprot);
}
iprot->readListEnd();
}
@@ -10589,14 +11279,14 @@ uint32_t ThriftHiveMetastore_get_index_n
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size456;
- ::apache::thrift::protocol::TType _etype459;
- iprot->readListBegin(_etype459, _size456);
- this->success.resize(_size456);
- uint32_t _i460;
- for (_i460 = 0; _i460 < _size456; ++_i460)
+ uint32_t _size476;
+ ::apache::thrift::protocol::TType _etype479;
+ iprot->readListBegin(_etype479, _size476);
+ this->success.resize(_size476);
+ uint32_t _i480;
+ for (_i480 = 0; _i480 < _size476; ++_i480)
{
- xfer += iprot->readString(this->success[_i460]);
+ xfer += iprot->readString(this->success[_i480]);
}
iprot->readListEnd();
}
@@ -10635,10 +11325,10 @@ uint32_t ThriftHiveMetastore_get_index_n
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->success.size());
- std::vector<std::string> ::const_iterator _iter461;
- for (_iter461 = this->success.begin(); _iter461 != this->success.end(); ++_iter461)
+ std::vector<std::string> ::const_iterator _iter481;
+ for (_iter481 = this->success.begin(); _iter481 != this->success.end(); ++_iter481)
{
- xfer += oprot->writeString((*_iter461));
+ xfer += oprot->writeString((*_iter481));
}
xfer += oprot->writeListEnd();
}
@@ -10677,14 +11367,14 @@ uint32_t ThriftHiveMetastore_get_index_n
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size462;
- ::apache::thrift::protocol::TType _etype465;
- iprot->readListBegin(_etype465, _size462);
- (*(this->success)).resize(_size462);
- uint32_t _i466;
- for (_i466 = 0; _i466 < _size462; ++_i466)
+ uint32_t _size482;
+ ::apache::thrift::protocol::TType _etype485;
+ iprot->readListBegin(_etype485, _size482);
+ (*(this->success)).resize(_size482);
+ uint32_t _i486;
+ for (_i486 = 0; _i486 < _size482; ++_i486)
{
- xfer += iprot->readString((*(this->success))[_i466]);
+ xfer += iprot->readString((*(this->success))[_i486]);
}
iprot->readListEnd();
}
@@ -11141,14 +11831,14 @@ uint32_t ThriftHiveMetastore_get_role_na
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size467;
- ::apache::thrift::protocol::TType _etype470;
- iprot->readListBegin(_etype470, _size467);
- this->success.resize(_size467);
- uint32_t _i471;
- for (_i471 = 0; _i471 < _size467; ++_i471)
+ uint32_t _size487;
+ ::apache::thrift::protocol::TType _etype490;
+ iprot->readListBegin(_etype490, _size487);
+ this->success.resize(_size487);
+ uint32_t _i491;
+ for (_i491 = 0; _i491 < _size487; ++_i491)
{
- xfer += iprot->readString(this->success[_i471]);
+ xfer += iprot->readString(this->success[_i491]);
}
iprot->readListEnd();
}
@@ -11187,10 +11877,10 @@ uint32_t ThriftHiveMetastore_get_role_na
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->success.size());
- std::vector<std::string> ::const_iterator _iter472;
- for (_iter472 = this->success.begin(); _iter472 != this->success.end(); ++_iter472)
+ std::vector<std::string> ::const_iterator _iter492;
+ for (_iter492 = this->success.begin(); _iter492 != this->success.end(); ++_iter492)
{
- xfer += oprot->writeString((*_iter472));
+ xfer += oprot->writeString((*_iter492));
}
xfer += oprot->writeListEnd();
}
@@ -11229,14 +11919,14 @@ uint32_t ThriftHiveMetastore_get_role_na
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size473;
- ::apache::thrift::protocol::TType _etype476;
- iprot->readListBegin(_etype476, _size473);
- (*(this->success)).resize(_size473);
- uint32_t _i477;
- for (_i477 = 0; _i477 < _size473; ++_i477)
+ uint32_t _size493;
+ ::apache::thrift::protocol::TType _etype496;
+ iprot->readListBegin(_etype496, _size493);
+ (*(this->success)).resize(_size493);
+ uint32_t _i497;
+ for (_i497 = 0; _i497 < _size493; ++_i497)
{
- xfer += iprot->readString((*(this->success))[_i477]);
+ xfer += iprot->readString((*(this->success))[_i497]);
}
iprot->readListEnd();
}
@@ -11303,9 +11993,9 @@ uint32_t ThriftHiveMetastore_grant_role_
break;
case 3:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast478;
- xfer += iprot->readI32(ecast478);
- this->principal_type = (PrincipalType::type)ecast478;
+ int32_t ecast498;
+ xfer += iprot->readI32(ecast498);
+ this->principal_type = (PrincipalType::type)ecast498;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -11321,9 +12011,9 @@ uint32_t ThriftHiveMetastore_grant_role_
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast479;
- xfer += iprot->readI32(ecast479);
- this->grantorType = (PrincipalType::type)ecast479;
+ int32_t ecast499;
+ xfer += iprot->readI32(ecast499);
+ this->grantorType = (PrincipalType::type)ecast499;
this->__isset.grantorType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11555,9 +12245,9 @@ uint32_t ThriftHiveMetastore_revoke_role
break;
case 3:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast480;
- xfer += iprot->readI32(ecast480);
- this->principal_type = (PrincipalType::type)ecast480;
+ int32_t ecast500;
+ xfer += iprot->readI32(ecast500);
+ this->principal_type = (PrincipalType::type)ecast500;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -11755,9 +12445,9 @@ uint32_t ThriftHiveMetastore_list_roles_
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast481;
- xfer += iprot->readI32(ecast481);
- this->principal_type = (PrincipalType::type)ecast481;
+ int32_t ecast501;
+ xfer += iprot->readI32(ecast501);
+ this->principal_type = (PrincipalType::type)ecast501;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -11827,14 +12517,14 @@ uint32_t ThriftHiveMetastore_list_roles_
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size482;
- ::apache::thrift::protocol::TType _etype485;
- iprot->readListBegin(_etype485, _size482);
- this->success.resize(_size482);
- uint32_t _i486;
- for (_i486 = 0; _i486 < _size482; ++_i486)
+ uint32_t _size502;
+ ::apache::thrift::protocol::TType _etype505;
+ iprot->readListBegin(_etype505, _size502);
+ this->success.resize(_size502);
+ uint32_t _i506;
+ for (_i506 = 0; _i506 < _size502; ++_i506)
{
- xfer += this->success[_i486].read(iprot);
+ xfer += this->success[_i506].read(iprot);
}
iprot->readListEnd();
}
@@ -11873,10 +12563,10 @@ uint32_t ThriftHiveMetastore_list_roles_
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
- std::vector<Role> ::const_iterator _iter487;
- for (_iter487 = this->success.begin(); _iter487 != this->success.end(); ++_iter487)
+ std::vector<Role> ::const_iterator _iter507;
+ for (_iter507 = this->success.begin(); _iter507 != this->success.end(); ++_iter507)
{
- xfer += (*_iter487).write(oprot);
+ xfer += (*_iter507).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11915,14 +12605,14 @@ uint32_t ThriftHiveMetastore_list_roles_
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size488;
- ::apache::thrift::protocol::TType _etype491;
- iprot->readListBegin(_etype491, _size488);
- (*(this->success)).resize(_size488);
- uint32_t _i492;
- for (_i492 = 0; _i492 < _size488; ++_i492)
+ uint32_t _size508;
+ ::apache::thrift::protocol::TType _etype511;
+ iprot->readListBegin(_etype511, _size508);
+ (*(this->success)).resize(_size508);
+ uint32_t _i512;
+ for (_i512 = 0; _i512 < _size508; ++_i512)
{
- xfer += (*(this->success))[_i492].read(iprot);
+ xfer += (*(this->success))[_i512].read(iprot);
}
iprot->readListEnd();
}
@@ -11991,14 +12681,14 @@ uint32_t ThriftHiveMetastore_get_privile
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->group_names.clear();
- uint32_t _size493;
- ::apache::thrift::protocol::TType _etype496;
- iprot->readListBegin(_etype496, _size493);
- this->group_names.resize(_size493);
- uint32_t _i497;
- for (_i497 = 0; _i497 < _size493; ++_i497)
+ uint32_t _size513;
+ ::apache::thrift::protocol::TType _etype516;
+ iprot->readListBegin(_etype516, _size513);
+ this->group_names.resize(_size513);
+ uint32_t _i517;
+ for (_i517 = 0; _i517 < _size513; ++_i517)
{
- xfer += iprot->readString(this->group_names[_i497]);
+ xfer += iprot->readString(this->group_names[_i517]);
}
iprot->readListEnd();
}
@@ -12031,10 +12721,10 @@ uint32_t ThriftHiveMetastore_get_privile
xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->group_names.size());
- std::vector<std::string> ::const_iterator _iter498;
- for (_iter498 = this->group_names.begin(); _iter498 != this->group_names.end(); ++_iter498)
+ std::vector<std::string> ::const_iterator _iter518;
+ for (_iter518 = this->group_names.begin(); _iter518 != this->group_names.end(); ++_iter518)
{
- xfer += oprot->writeString((*_iter498));
+ xfer += oprot->writeString((*_iter518));
}
xfer += oprot->writeListEnd();
}
@@ -12056,10 +12746,10 @@ uint32_t ThriftHiveMetastore_get_privile
xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, (*(this->group_names)).size());
- std::vector<std::string> ::const_iterator _iter499;
- for (_iter499 = (*(this->group_names)).begin(); _iter499 != (*(this->group_names)).end(); ++_iter499)
+ std::vector<std::string> ::const_iterator _iter519;
+ for (_iter519 = (*(this->group_names)).begin(); _iter519 != (*(this->group_names)).end(); ++_iter519)
{
- xfer += oprot->writeString((*_iter499));
+ xfer += oprot->writeString((*_iter519));
}
xfer += oprot->writeListEnd();
}
@@ -12215,9 +12905,9 @@ uint32_t ThriftHiveMetastore_list_privil
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast500;
- xfer += iprot->readI32(ecast500);
- this->principal_type = (PrincipalType::type)ecast500;
+ int32_t ecast520;
+ xfer += iprot->readI32(ecast520);
+ this->principal_type = (PrincipalType::type)ecast520;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -12301,14 +12991,14 @@ uint32_t ThriftHiveMetastore_list_privil
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size501;
- ::apache::thrift::protocol::TType _etype504;
- iprot->readListBegin(_etype504, _size501);
- this->success.resize(_size501);
- uint32_t _i505;
- for (_i505 = 0; _i505 < _size501; ++_i505)
+ uint32_t _size521;
+ ::apache::thrift::protocol::TType _etype524;
+ iprot->readListBegin(_etype524, _size521);
+ this->success.resize(_size521);
+ uint32_t _i525;
+ for (_i525 = 0; _i525 < _size521; ++_i525)
{
- xfer += this->success[_i505].read(iprot);
+ xfer += this->success[_i525].read(iprot);
}
iprot->readListEnd();
}
@@ -12347,10 +13037,10 @@ uint32_t ThriftHiveMetastore_list_privil
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
- std::vector<HiveObjectPrivilege> ::const_iterator _iter506;
- for (_iter506 = this->success.begin(); _iter506 != this->success.end(); ++_iter506)
+ std::vector<HiveObjectPrivilege> ::const_iterator _iter526;
+ for (_iter526 = this->success.begin(); _iter526 != this->success.end(); ++_iter526)
{
- xfer += (*_iter506).write(oprot);
+ xfer += (*_iter526).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12389,14 +13079,14 @@ uint32_t ThriftHiveMetastore_list_privil
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size507;
- ::apache::thrift::protocol::TType _etype510;
- iprot->readListBegin(_etype510, _size507);
- (*(this->success)).resize(_size507);
- uint32_t _i511;
- for (_i511 = 0; _i511 < _size507; ++_i511)
+ uint32_t _size527;
+ ::apache::thrift::protocol::TType _etype530;
+ iprot->readListBegin(_etype530, _size527);
+ (*(this->success)).resize(_size527);
+ uint32_t _i531;
+ for (_i531 = 0; _i531 < _size527; ++_i531)
{
- xfer += (*(this->success))[_i511].read(iprot);
+ xfer += (*(this->success))[_i531].read(iprot);
}
iprot->readListEnd();
}
@@ -15904,6 +16594,163 @@ void ThriftHiveMetastoreClient::recv_par
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "partition_name_to_spec failed: unknown result");
}
+void ThriftHiveMetastoreClient::markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType)
+{
+ send_markPartitionForEvent(db_name, tbl_name, part_vals, eventType);
+ recv_markPartitionForEvent();
+}
+
+void ThriftHiveMetastoreClient::send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("markPartitionForEvent", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_markPartitionForEvent_pargs args;
+ args.db_name = &db_name;
+ args.tbl_name = &tbl_name;
+ args.part_vals = &part_vals;
+ args.eventType = &eventType;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->flush();
+ oprot_->getTransport()->writeEnd();
+}
+
+void ThriftHiveMetastoreClient::recv_markPartitionForEvent()
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+ }
+ if (fname.compare("markPartitionForEvent") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+ }
+ ThriftHiveMetastore_markPartitionForEvent_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ if (result.__isset.o3) {
+ throw result.o3;
+ }
+ if (result.__isset.o4) {
+ throw result.o4;
+ }
+ if (result.__isset.o5) {
+ throw result.o5;
+ }
+ if (result.__isset.o6) {
+ throw result.o6;
+ }
+ return;
+}
+
+bool ThriftHiveMetastoreClient::isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType)
+{
+ send_isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType);
+ return recv_isPartitionMarkedForEvent();
+}
+
+void ThriftHiveMetastoreClient::send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("isPartitionMarkedForEvent", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_isPartitionMarkedForEvent_pargs args;
+ args.db_name = &db_name;
+ args.tbl_name = &tbl_name;
+ args.part_vals = &part_vals;
+ args.eventType = &eventType;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->flush();
+ oprot_->getTransport()->writeEnd();
+}
+
+bool ThriftHiveMetastoreClient::recv_isPartitionMarkedForEvent()
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+ }
+ if (fname.compare("isPartitionMarkedForEvent") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+ }
+ bool _return;
+ ThriftHiveMetastore_isPartitionMarkedForEvent_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ return _return;
+ }
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ if (result.__isset.o3) {
+ throw result.o3;
+ }
+ if (result.__isset.o4) {
+ throw result.o4;
+ }
+ if (result.__isset.o5) {
+ throw result.o5;
+ }
+ if (result.__isset.o6) {
+ throw result.o6;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isPartitionMarkedForEvent failed: unknown result");
+}
+
void ThriftHiveMetastoreClient::add_index(Index& _return, const Index& new_index, const Table& index_table)
{
send_add_index(new_index, index_table);
@@ -18489,6 +19336,97 @@ void ThriftHiveMetastoreProcessor::proce
oprot->getTransport()->writeEnd();
}
+void ThriftHiveMetastoreProcessor::process_markPartitionForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot)
+{
+ ThriftHiveMetastore_markPartitionForEvent_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ iprot->getTransport()->readEnd();
+
+ ThriftHiveMetastore_markPartitionForEvent_result result;
+ try {
+ iface_->markPartitionForEvent(args.db_name, args.tbl_name, args.part_vals, args.eventType);
+ } catch (MetaException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (NoSuchObjectException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (UnknownDBException &o3) {
+ result.o3 = o3;
+ result.__isset.o3 = true;
+ } catch (UnknownTableException &o4) {
+ result.o4 = o4;
+ result.__isset.o4 = true;
+ } catch (UnknownPartitionException &o5) {
+ result.o5 = o5;
+ result.__isset.o5 = true;
+ } catch (InvalidPartitionException &o6) {
+ result.o6 = o6;
+ result.__isset.o6 = true;
+ } catch (const std::exception& e) {
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("markPartitionForEvent", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->flush();
+ oprot->getTransport()->writeEnd();
+ return;
+ }
+
+ oprot->writeMessageBegin("markPartitionForEvent", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->flush();
+ oprot->getTransport()->writeEnd();
+}
+
+void ThriftHiveMetastoreProcessor::process_isPartitionMarkedForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot)
+{
+ ThriftHiveMetastore_isPartitionMarkedForEvent_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ iprot->getTransport()->readEnd();
+
+ ThriftHiveMetastore_isPartitionMarkedForEvent_result result;
+ try {
+ result.success = iface_->isPartitionMarkedForEvent(args.db_name, args.tbl_name, args.part_vals, args.eventType);
+ result.__isset.success = true;
+ } catch (MetaException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (NoSuchObjectException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (UnknownDBException &o3) {
+ result.o3 = o3;
+ result.__isset.o3 = true;
+ } catch (UnknownTableException &o4) {
+ result.o4 = o4;
+ result.__isset.o4 = true;
+ } catch (UnknownPartitionException &o5) {
+ result.o5 = o5;
+ result.__isset.o5 = true;
+ } catch (InvalidPartitionException &o6) {
+ result.o6 = o6;
+ result.__isset.o6 = true;
+ } catch (const std::exception& e) {
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("isPartitionMarkedForEvent", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->flush();
+ oprot->getTransport()->writeEnd();
+ return;
+ }
+
+ oprot->writeMessageBegin("isPartitionMarkedForEvent", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->flush();
+ oprot->getTransport()->writeEnd();
+}
+
void ThriftHiveMetastoreProcessor::process_add_index(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot)
{
ThriftHiveMetastore_add_index_args args;
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1137561&r1=1137560&r2=1137561&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Mon Jun 20 09:28:55 2011
@@ -54,6 +54,8 @@ class ThriftHiveMetastoreIf : virtual pu
virtual void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) = 0;
virtual void partition_name_to_vals(std::vector<std::string> & _return, const std::string& part_name) = 0;
virtual void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name) = 0;
+ virtual void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) = 0;
+ virtual bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) = 0;
virtual void add_index(Index& _return, const Index& new_index, const Table& index_table) = 0;
virtual void alter_index(const std::string& dbname, const std::string& base_tbl_name, const std::string& idx_name, const Index& new_idx) = 0;
virtual bool drop_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name, const bool deleteData) = 0;
@@ -199,6 +201,13 @@ class ThriftHiveMetastoreNull : virtual
void partition_name_to_spec(std::map<std::string, std::string> & /* _return */, const std::string& /* part_name */) {
return;
}
+ void markPartitionForEvent(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::map<std::string, std::string> & /* part_vals */, const PartitionEventType::type /* eventType */) {
+ return;
+ }
+ bool isPartitionMarkedForEvent(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::map<std::string, std::string> & /* part_vals */, const PartitionEventType::type /* eventType */) {
+ bool _return = false;
+ return _return;
+ }
void add_index(Index& /* _return */, const Index& /* new_index */, const Table& /* index_table */) {
return;
}
@@ -4867,6 +4876,302 @@ class ThriftHiveMetastore_partition_name
};
+typedef struct _ThriftHiveMetastore_markPartitionForEvent_args__isset {
+ _ThriftHiveMetastore_markPartitionForEvent_args__isset() : db_name(false), tbl_name(false), part_vals(false), eventType(false) {}
+ bool db_name;
+ bool tbl_name;
+ bool part_vals;
+ bool eventType;
+} _ThriftHiveMetastore_markPartitionForEvent_args__isset;
+
+class ThriftHiveMetastore_markPartitionForEvent_args {
+ public:
+
+ ThriftHiveMetastore_markPartitionForEvent_args() : db_name(""), tbl_name("") {
+ }
+
+ virtual ~ThriftHiveMetastore_markPartitionForEvent_args() throw() {}
+
+ std::string db_name;
+ std::string tbl_name;
+ std::map<std::string, std::string> part_vals;
+ PartitionEventType::type eventType;
+
+ _ThriftHiveMetastore_markPartitionForEvent_args__isset __isset;
+
+ bool operator == (const ThriftHiveMetastore_markPartitionForEvent_args & rhs) const
+ {
+ if (!(db_name == rhs.db_name))
+ return false;
+ if (!(tbl_name == rhs.tbl_name))
+ return false;
+ if (!(part_vals == rhs.part_vals))
+ return false;
+ if (!(eventType == rhs.eventType))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_markPartitionForEvent_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_markPartitionForEvent_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_markPartitionForEvent_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_markPartitionForEvent_pargs() throw() {}
+
+ const std::string* db_name;
+ const std::string* tbl_name;
+ const std::map<std::string, std::string> * part_vals;
+ const PartitionEventType::type* eventType;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_markPartitionForEvent_result__isset {
+ _ThriftHiveMetastore_markPartitionForEvent_result__isset() : o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
+ bool o1;
+ bool o2;
+ bool o3;
+ bool o4;
+ bool o5;
+ bool o6;
+} _ThriftHiveMetastore_markPartitionForEvent_result__isset;
+
+class ThriftHiveMetastore_markPartitionForEvent_result {
+ public:
+
+ ThriftHiveMetastore_markPartitionForEvent_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_markPartitionForEvent_result() throw() {}
+
+ MetaException o1;
+ NoSuchObjectException o2;
+ UnknownDBException o3;
+ UnknownTableException o4;
+ UnknownPartitionException o5;
+ InvalidPartitionException o6;
+
+ _ThriftHiveMetastore_markPartitionForEvent_result__isset __isset;
+
+ bool operator == (const ThriftHiveMetastore_markPartitionForEvent_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ if (!(o3 == rhs.o3))
+ return false;
+ if (!(o4 == rhs.o4))
+ return false;
+ if (!(o5 == rhs.o5))
+ return false;
+ if (!(o6 == rhs.o6))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_markPartitionForEvent_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_markPartitionForEvent_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_markPartitionForEvent_presult__isset {
+ _ThriftHiveMetastore_markPartitionForEvent_presult__isset() : o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
+ bool o1;
+ bool o2;
+ bool o3;
+ bool o4;
+ bool o5;
+ bool o6;
+} _ThriftHiveMetastore_markPartitionForEvent_presult__isset;
+
+class ThriftHiveMetastore_markPartitionForEvent_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_markPartitionForEvent_presult() throw() {}
+
+ MetaException o1;
+ NoSuchObjectException o2;
+ UnknownDBException o3;
+ UnknownTableException o4;
+ UnknownPartitionException o5;
+ InvalidPartitionException o6;
+
+ _ThriftHiveMetastore_markPartitionForEvent_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset {
+ _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset() : db_name(false), tbl_name(false), part_vals(false), eventType(false) {}
+ bool db_name;
+ bool tbl_name;
+ bool part_vals;
+ bool eventType;
+} _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset;
+
+class ThriftHiveMetastore_isPartitionMarkedForEvent_args {
+ public:
+
+ ThriftHiveMetastore_isPartitionMarkedForEvent_args() : db_name(""), tbl_name("") {
+ }
+
+ virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_args() throw() {}
+
+ std::string db_name;
+ std::string tbl_name;
+ std::map<std::string, std::string> part_vals;
+ PartitionEventType::type eventType;
+
+ _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset __isset;
+
+ bool operator == (const ThriftHiveMetastore_isPartitionMarkedForEvent_args & rhs) const
+ {
+ if (!(db_name == rhs.db_name))
+ return false;
+ if (!(tbl_name == rhs.tbl_name))
+ return false;
+ if (!(part_vals == rhs.part_vals))
+ return false;
+ if (!(eventType == rhs.eventType))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_isPartitionMarkedForEvent_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_isPartitionMarkedForEvent_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_isPartitionMarkedForEvent_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_pargs() throw() {}
+
+ const std::string* db_name;
+ const std::string* tbl_name;
+ const std::map<std::string, std::string> * part_vals;
+ const PartitionEventType::type* eventType;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset {
+ _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+ bool o3;
+ bool o4;
+ bool o5;
+ bool o6;
+} _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset;
+
+class ThriftHiveMetastore_isPartitionMarkedForEvent_result {
+ public:
+
+ ThriftHiveMetastore_isPartitionMarkedForEvent_result() : success(0) {
+ }
+
+ virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_result() throw() {}
+
+ bool success;
+ MetaException o1;
+ NoSuchObjectException o2;
+ UnknownDBException o3;
+ UnknownTableException o4;
+ UnknownPartitionException o5;
+ InvalidPartitionException o6;
+
+ _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset __isset;
+
+ bool operator == (const ThriftHiveMetastore_isPartitionMarkedForEvent_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ if (!(o3 == rhs.o3))
+ return false;
+ if (!(o4 == rhs.o4))
+ return false;
+ if (!(o5 == rhs.o5))
+ return false;
+ if (!(o6 == rhs.o6))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_isPartitionMarkedForEvent_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_isPartitionMarkedForEvent_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset {
+ _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+ bool o3;
+ bool o4;
+ bool o5;
+ bool o6;
+} _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset;
+
+class ThriftHiveMetastore_isPartitionMarkedForEvent_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_presult() throw() {}
+
+ bool* success;
+ MetaException o1;
+ NoSuchObjectException o2;
+ UnknownDBException o3;
+ UnknownTableException o4;
+ UnknownPartitionException o5;
+ InvalidPartitionException o6;
+
+ _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
typedef struct _ThriftHiveMetastore_add_index_args__isset {
_ThriftHiveMetastore_add_index_args__isset() : new_index(false), index_table(false) {}
bool new_index;
@@ -7154,6 +7459,12 @@ class ThriftHiveMetastoreClient : virtua
void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name);
void send_partition_name_to_spec(const std::string& part_name);
void recv_partition_name_to_spec(std::map<std::string, std::string> & _return);
+ void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+ void send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+ void recv_markPartitionForEvent();
+ bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+ void send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+ bool recv_isPartitionMarkedForEvent();
void add_index(Index& _return, const Index& new_index, const Table& index_table);
void send_add_index(const Index& new_index, const Table& index_table);
void recv_add_index(Index& _return);
@@ -7258,6 +7569,8 @@ class ThriftHiveMetastoreProcessor : vir
void process_get_config_value(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_partition_name_to_vals(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_partition_name_to_spec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+ void process_markPartitionForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+ void process_isPartitionMarkedForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_add_index(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_alter_index(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_drop_index_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
@@ -7320,6 +7633,8 @@ class ThriftHiveMetastoreProcessor : vir
processMap_["get_config_value"] = &ThriftHiveMetastoreProcessor::process_get_config_value;
processMap_["partition_name_to_vals"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_vals;
processMap_["partition_name_to_spec"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_spec;
+ processMap_["markPartitionForEvent"] = &ThriftHiveMetastoreProcessor::process_markPartitionForEvent;
+ processMap_["isPartitionMarkedForEvent"] = &ThriftHiveMetastoreProcessor::process_isPartitionMarkedForEvent;
processMap_["add_index"] = &ThriftHiveMetastoreProcessor::process_add_index;
processMap_["alter_index"] = &ThriftHiveMetastoreProcessor::process_alter_index;
processMap_["drop_index_by_name"] = &ThriftHiveMetastoreProcessor::process_drop_index_by_name;
@@ -7791,6 +8106,24 @@ class ThriftHiveMetastoreMultiface : vir
}
}
+ void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ ifaces_[i]->markPartitionForEvent(db_name, tbl_name, part_vals, eventType);
+ }
+ }
+
+ bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ return ifaces_[i]->isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType);
+ } else {
+ ifaces_[i]->isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType);
+ }
+ }
+ }
+
void add_index(Index& _return, const Index& new_index, const Table& index_table) {
uint32_t sz = ifaces_.size();
for (uint32_t i = 0; i < sz; ++i) {
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1137561&r1=1137560&r2=1137561&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Mon Jun 20 09:28:55 2011
@@ -217,6 +217,16 @@ class ThriftHiveMetastoreHandler : virtu
printf("partition_name_to_spec\n");
}
+ void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) {
+ // Your implementation goes here
+ printf("markPartitionForEvent\n");
+ }
+
+ bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) {
+ // Your implementation goes here
+ printf("isPartitionMarkedForEvent\n");
+ }
+
void add_index(Index& _return, const Index& new_index, const Table& index_table) {
// Your implementation goes here
printf("add_index\n");
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1137561&r1=1137560&r2=1137561&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Mon Jun 20 09:28:55 2011
@@ -2365,6 +2365,114 @@ uint32_t AlreadyExistsException::write(:
return xfer;
}
+const char* InvalidPartitionException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t InvalidPartitionException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t InvalidPartitionException::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;
+
+
+ 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->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t InvalidPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("InvalidPartitionException");
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* UnknownPartitionException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t UnknownPartitionException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t UnknownPartitionException::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;
+
+
+ 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->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t UnknownPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("UnknownPartitionException");
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
const char* InvalidObjectException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
const uint8_t InvalidObjectException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1137561&r1=1137560&r2=1137561&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Mon Jun 20 09:28:55 2011
@@ -34,6 +34,12 @@ struct PrincipalType {
};
};
+struct PartitionEventType {
+ enum type {
+ LOAD_DONE = 1
+ };
+};
+
typedef struct _Version__isset {
_Version__isset() : version(false), comments(false) {}
bool version;
@@ -1087,6 +1093,80 @@ class AlreadyExistsException : public ::
};
+typedef struct _InvalidPartitionException__isset {
+ _InvalidPartitionException__isset() : message(false) {}
+ bool message;
+} _InvalidPartitionException__isset;
+
+class InvalidPartitionException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+ static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+ InvalidPartitionException() : message("") {
+ }
+
+ virtual ~InvalidPartitionException() throw() {}
+
+ std::string message;
+
+ _InvalidPartitionException__isset __isset;
+
+ bool operator == (const InvalidPartitionException & rhs) const
+ {
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const InvalidPartitionException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const InvalidPartitionException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _UnknownPartitionException__isset {
+ _UnknownPartitionException__isset() : message(false) {}
+ bool message;
+} _UnknownPartitionException__isset;
+
+class UnknownPartitionException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+ static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+ UnknownPartitionException() : message("") {
+ }
+
+ virtual ~UnknownPartitionException() throw() {}
+
+ std::string message;
+
+ _UnknownPartitionException__isset __isset;
+
+ bool operator == (const UnknownPartitionException & rhs) const
+ {
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const UnknownPartitionException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const UnknownPartitionException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
typedef struct _InvalidObjectException__isset {
_InvalidObjectException__isset() : message(false) {}
bool message;
Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InvalidPartitionException.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InvalidPartitionException.java?rev=1137561&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InvalidPartitionException.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InvalidPartitionException.java Mon Jun 20 09:28:55 2011
@@ -0,0 +1,306 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.thrift.*;
+import org.apache.thrift.async.*;
+import org.apache.thrift.meta_data.*;
+import org.apache.thrift.transport.*;
+import org.apache.thrift.protocol.*;
+
+public class InvalidPartitionException extends Exception implements TBase<InvalidPartitionException, InvalidPartitionException._Fields>, java.io.Serializable, Cloneable {
+ private static final TStruct STRUCT_DESC = new TStruct("InvalidPartitionException");
+
+ private static final TField MESSAGE_FIELD_DESC = new TField("message", TType.STRING, (short)1);
+
+ private String message;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ MESSAGE((short)1, "message");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // MESSAGE
+ return MESSAGE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+
+ public static final Map<_Fields, FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.MESSAGE, new FieldMetaData("message", TFieldRequirementType.DEFAULT,
+ new FieldValueMetaData(TType.STRING)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ FieldMetaData.addStructMetaDataMap(InvalidPartitionException.class, metaDataMap);
+ }
+
+ public InvalidPartitionException() {
+ }
+
+ public InvalidPartitionException(
+ String message)
+ {
+ this();
+ this.message = message;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public InvalidPartitionException(InvalidPartitionException other) {
+ if (other.isSetMessage()) {
+ this.message = other.message;
+ }
+ }
+
+ public InvalidPartitionException deepCopy() {
+ return new InvalidPartitionException(this);
+ }
+
+ @Override
+ public void clear() {
+ this.message = null;
+ }
+
+ public String getMessage() {
+ return this.message;
+ }
+
+ public void setMessage(String message) {
+ this.message = message;
+ }
+
+ public void unsetMessage() {
+ this.message = null;
+ }
+
+ /** Returns true if field message is set (has been asigned a value) and false otherwise */
+ public boolean isSetMessage() {
+ return this.message != null;
+ }
+
+ public void setMessageIsSet(boolean value) {
+ if (!value) {
+ this.message = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case MESSAGE:
+ if (value == null) {
+ unsetMessage();
+ } else {
+ setMessage((String)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case MESSAGE:
+ return getMessage();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case MESSAGE:
+ return isSetMessage();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof InvalidPartitionException)
+ return this.equals((InvalidPartitionException)that);
+ return false;
+ }
+
+ public boolean equals(InvalidPartitionException that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_message = true && this.isSetMessage();
+ boolean that_present_message = true && that.isSetMessage();
+ if (this_present_message || that_present_message) {
+ if (!(this_present_message && that_present_message))
+ return false;
+ if (!this.message.equals(that.message))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+
+ public int compareTo(InvalidPartitionException other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ InvalidPartitionException typedOther = (InvalidPartitionException)other;
+
+ lastComparison = Boolean.valueOf(isSetMessage()).compareTo(typedOther.isSetMessage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMessage()) {
+ lastComparison = TBaseHelper.compareTo(this.message, typedOther.message);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ switch (field.id) {
+ case 1: // MESSAGE
+ if (field.type == TType.STRING) {
+ this.message = iprot.readString();
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ default:
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ validate();
+ }
+
+ public void write(TProtocol oprot) throws TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (this.message != null) {
+ oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+ oprot.writeString(this.message);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("InvalidPartitionException(");
+ boolean first = true;
+
+ sb.append("message:");
+ if (this.message == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.message);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws TException {
+ // check for required fields
+ }
+
+}
+
Propchange: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/InvalidPartitionException.java
------------------------------------------------------------------------------
svn:eol-style = native