hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From khorg...@apache.org
Subject svn commit: r1650145 [3/8] - in /hive/trunk: common/src/java/org/apache/hadoop/hive/conf/ hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/ hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/messaging/json/ ites...
Date Wed, 07 Jan 2015 20:15:11 GMT
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=1650145&r1=1650144&r2=1650145&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Wed Jan  7 20:15:10 2015
@@ -133,6 +133,8 @@ class ThriftHiveMetastoreIf : virtual pu
   virtual void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) = 0;
   virtual void compact(const CompactionRequest& rqst) = 0;
   virtual void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) = 0;
+  virtual void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) = 0;
+  virtual void getCurrentNotificationEventId(CurrentNotificationEventId& _return) = 0;
 };
 
 class ThriftHiveMetastoreIfFactory : virtual public  ::facebook::fb303::FacebookServiceIfFactory {
@@ -536,6 +538,12 @@ class ThriftHiveMetastoreNull : virtual
   void show_compact(ShowCompactResponse& /* _return */, const ShowCompactRequest& /* rqst */) {
     return;
   }
+  void getNextNotification(NotificationEventResponse& /* _return */, const NotificationEventRequest& /* rqst */) {
+    return;
+  }
+  void getCurrentNotificationEventId(CurrentNotificationEventId& /* _return */) {
+    return;
+  }
 };
 
 typedef struct _ThriftHiveMetastore_getMetaConf_args__isset {
@@ -16567,6 +16575,208 @@ class ThriftHiveMetastore_show_compact_p
 
 };
 
+typedef struct _ThriftHiveMetastore_getNextNotification_args__isset {
+  _ThriftHiveMetastore_getNextNotification_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_getNextNotification_args__isset;
+
+class ThriftHiveMetastore_getNextNotification_args {
+ public:
+
+  ThriftHiveMetastore_getNextNotification_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_getNextNotification_args() throw() {}
+
+  NotificationEventRequest rqst;
+
+  _ThriftHiveMetastore_getNextNotification_args__isset __isset;
+
+  void __set_rqst(const NotificationEventRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_getNextNotification_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_getNextNotification_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_getNextNotification_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_getNextNotification_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_getNextNotification_pargs() throw() {}
+
+  const NotificationEventRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getNextNotification_result__isset {
+  _ThriftHiveMetastore_getNextNotification_result__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_getNextNotification_result__isset;
+
+class ThriftHiveMetastore_getNextNotification_result {
+ public:
+
+  ThriftHiveMetastore_getNextNotification_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_getNextNotification_result() throw() {}
+
+  NotificationEventResponse success;
+
+  _ThriftHiveMetastore_getNextNotification_result__isset __isset;
+
+  void __set_success(const NotificationEventResponse& val) {
+    success = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_getNextNotification_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_getNextNotification_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_getNextNotification_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getNextNotification_presult__isset {
+  _ThriftHiveMetastore_getNextNotification_presult__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_getNextNotification_presult__isset;
+
+class ThriftHiveMetastore_getNextNotification_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_getNextNotification_presult() throw() {}
+
+  NotificationEventResponse* success;
+
+  _ThriftHiveMetastore_getNextNotification_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_args {
+ public:
+
+  ThriftHiveMetastore_getCurrentNotificationEventId_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_args() throw() {}
+
+
+  bool operator == (const ThriftHiveMetastore_getCurrentNotificationEventId_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_getCurrentNotificationEventId_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_getCurrentNotificationEventId_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset {
+  _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset;
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_result {
+ public:
+
+  ThriftHiveMetastore_getCurrentNotificationEventId_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_result() throw() {}
+
+  CurrentNotificationEventId success;
+
+  _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset __isset;
+
+  void __set_success(const CurrentNotificationEventId& val) {
+    success = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_getCurrentNotificationEventId_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_getCurrentNotificationEventId_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_getCurrentNotificationEventId_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset {
+  _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset;
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_presult() throw() {}
+
+  CurrentNotificationEventId* success;
+
+  _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceClient {
  public:
   ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
@@ -16930,6 +17140,12 @@ class ThriftHiveMetastoreClient : virtua
   void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst);
   void send_show_compact(const ShowCompactRequest& rqst);
   void recv_show_compact(ShowCompactResponse& _return);
+  void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst);
+  void send_getNextNotification(const NotificationEventRequest& rqst);
+  void recv_getNextNotification(NotificationEventResponse& _return);
+  void getCurrentNotificationEventId(CurrentNotificationEventId& _return);
+  void send_getCurrentNotificationEventId();
+  void recv_getCurrentNotificationEventId(CurrentNotificationEventId& _return);
 };
 
 class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceProcessor {
@@ -17057,6 +17273,8 @@ class ThriftHiveMetastoreProcessor : pub
   void process_heartbeat_txn_range(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_show_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getNextNotification(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getCurrentNotificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  public:
   ThriftHiveMetastoreProcessor(boost::shared_ptr<ThriftHiveMetastoreIf> iface) :
      ::facebook::fb303::FacebookServiceProcessor(iface),
@@ -17178,6 +17396,8 @@ class ThriftHiveMetastoreProcessor : pub
     processMap_["heartbeat_txn_range"] = &ThriftHiveMetastoreProcessor::process_heartbeat_txn_range;
     processMap_["compact"] = &ThriftHiveMetastoreProcessor::process_compact;
     processMap_["show_compact"] = &ThriftHiveMetastoreProcessor::process_show_compact;
+    processMap_["getNextNotification"] = &ThriftHiveMetastoreProcessor::process_getNextNotification;
+    processMap_["getCurrentNotificationEventId"] = &ThriftHiveMetastoreProcessor::process_getCurrentNotificationEventId;
   }
 
   virtual ~ThriftHiveMetastoreProcessor() {}
@@ -18332,6 +18552,26 @@ class ThriftHiveMetastoreMultiface : vir
     return;
   }
 
+  void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getNextNotification(_return, rqst);
+    }
+    ifaces_[i]->getNextNotification(_return, rqst);
+    return;
+  }
+
+  void getCurrentNotificationEventId(CurrentNotificationEventId& _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getCurrentNotificationEventId(_return);
+    }
+    ifaces_[i]->getCurrentNotificationEventId(_return);
+    return;
+  }
+
 };
 
 }}} // namespace

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=1650145&r1=1650144&r2=1650145&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 Wed Jan  7 20:15:10 2015
@@ -607,6 +607,16 @@ class ThriftHiveMetastoreHandler : virtu
     printf("show_compact\n");
   }
 
+  void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) {
+    // Your implementation goes here
+    printf("getNextNotification\n");
+  }
+
+  void getCurrentNotificationEventId(CurrentNotificationEventId& _return) {
+    // Your implementation goes here
+    printf("getCurrentNotificationEventId\n");
+  }
+
 };
 
 int main(int argc, char **argv) {

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=1650145&r1=1650144&r2=1650145&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 Wed Jan  7 20:15:10 2015
@@ -9282,6 +9282,374 @@ void swap(ShowCompactResponse &a, ShowCo
   swap(a.compacts, b.compacts);
 }
 
+const char* NotificationEventRequest::ascii_fingerprint = "6E578DA8AB10EED824A75534350EBAEF";
+const uint8_t NotificationEventRequest::binary_fingerprint[16] = {0x6E,0x57,0x8D,0xA8,0xAB,0x10,0xEE,0xD8,0x24,0xA7,0x55,0x34,0x35,0x0E,0xBA,0xEF};
+
+uint32_t NotificationEventRequest::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_lastEvent = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->lastEvent);
+          isset_lastEvent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->maxEvents);
+          this->__isset.maxEvents = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_lastEvent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t NotificationEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NotificationEventRequest");
+
+  xfer += oprot->writeFieldBegin("lastEvent", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->lastEvent);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.maxEvents) {
+    xfer += oprot->writeFieldBegin("maxEvents", ::apache::thrift::protocol::T_I32, 2);
+    xfer += oprot->writeI32(this->maxEvents);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
+  using ::std::swap;
+  swap(a.lastEvent, b.lastEvent);
+  swap(a.maxEvents, b.maxEvents);
+  swap(a.__isset, b.__isset);
+}
+
+const char* NotificationEvent::ascii_fingerprint = "ACAF0036D9999F3A389F490F5E22D369";
+const uint8_t NotificationEvent::binary_fingerprint[16] = {0xAC,0xAF,0x00,0x36,0xD9,0x99,0x9F,0x3A,0x38,0x9F,0x49,0x0F,0x5E,0x22,0xD3,0x69};
+
+uint32_t NotificationEvent::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_eventId = false;
+  bool isset_eventTime = false;
+  bool isset_eventType = false;
+  bool isset_message = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->eventId);
+          isset_eventId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->eventTime);
+          isset_eventTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->eventType);
+          isset_eventType = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->dbName);
+          this->__isset.dbName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->tableName);
+          this->__isset.tableName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->message);
+          isset_message = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_eventId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_eventTime)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_eventType)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_message)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t NotificationEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NotificationEvent");
+
+  xfer += oprot->writeFieldBegin("eventId", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->eventId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("eventTime", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32(this->eventTime);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->eventType);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.dbName) {
+    xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->dbName);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.tableName) {
+    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 5);
+    xfer += oprot->writeString(this->tableName);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 6);
+  xfer += oprot->writeString(this->message);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(NotificationEvent &a, NotificationEvent &b) {
+  using ::std::swap;
+  swap(a.eventId, b.eventId);
+  swap(a.eventTime, b.eventTime);
+  swap(a.eventType, b.eventType);
+  swap(a.dbName, b.dbName);
+  swap(a.tableName, b.tableName);
+  swap(a.message, b.message);
+  swap(a.__isset, b.__isset);
+}
+
+const char* NotificationEventResponse::ascii_fingerprint = "EE3DB23399639114BCD1782A0FB01818";
+const uint8_t NotificationEventResponse::binary_fingerprint[16] = {0xEE,0x3D,0xB2,0x33,0x99,0x63,0x91,0x14,0xBC,0xD1,0x78,0x2A,0x0F,0xB0,0x18,0x18};
+
+uint32_t NotificationEventResponse::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_events = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->events.clear();
+            uint32_t _size401;
+            ::apache::thrift::protocol::TType _etype404;
+            xfer += iprot->readListBegin(_etype404, _size401);
+            this->events.resize(_size401);
+            uint32_t _i405;
+            for (_i405 = 0; _i405 < _size401; ++_i405)
+            {
+              xfer += this->events[_i405].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_events = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_events)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NotificationEventResponse");
+
+  xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->events.size()));
+    std::vector<NotificationEvent> ::const_iterator _iter406;
+    for (_iter406 = this->events.begin(); _iter406 != this->events.end(); ++_iter406)
+    {
+      xfer += (*_iter406).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(NotificationEventResponse &a, NotificationEventResponse &b) {
+  using ::std::swap;
+  swap(a.events, b.events);
+}
+
+const char* CurrentNotificationEventId::ascii_fingerprint = "56A59CE7FFAF82BCA8A19FAACDE4FB75";
+const uint8_t CurrentNotificationEventId::binary_fingerprint[16] = {0x56,0xA5,0x9C,0xE7,0xFF,0xAF,0x82,0xBC,0xA8,0xA1,0x9F,0xAA,0xCD,0xE4,0xFB,0x75};
+
+uint32_t CurrentNotificationEventId::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_eventId = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->eventId);
+          isset_eventId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_eventId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t CurrentNotificationEventId::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("CurrentNotificationEventId");
+
+  xfer += oprot->writeFieldBegin("eventId", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->eventId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) {
+  using ::std::swap;
+  swap(a.eventId, b.eventId);
+}
+
 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/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=1650145&r1=1650144&r2=1650145&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 Wed Jan  7 20:15:10 2015
@@ -5078,6 +5078,218 @@ class ShowCompactResponse {
 
 void swap(ShowCompactResponse &a, ShowCompactResponse &b);
 
+typedef struct _NotificationEventRequest__isset {
+  _NotificationEventRequest__isset() : maxEvents(false) {}
+  bool maxEvents;
+} _NotificationEventRequest__isset;
+
+class NotificationEventRequest {
+ public:
+
+  static const char* ascii_fingerprint; // = "6E578DA8AB10EED824A75534350EBAEF";
+  static const uint8_t binary_fingerprint[16]; // = {0x6E,0x57,0x8D,0xA8,0xAB,0x10,0xEE,0xD8,0x24,0xA7,0x55,0x34,0x35,0x0E,0xBA,0xEF};
+
+  NotificationEventRequest() : lastEvent(0), maxEvents(0) {
+  }
+
+  virtual ~NotificationEventRequest() throw() {}
+
+  int64_t lastEvent;
+  int32_t maxEvents;
+
+  _NotificationEventRequest__isset __isset;
+
+  void __set_lastEvent(const int64_t val) {
+    lastEvent = val;
+  }
+
+  void __set_maxEvents(const int32_t val) {
+    maxEvents = val;
+    __isset.maxEvents = true;
+  }
+
+  bool operator == (const NotificationEventRequest & rhs) const
+  {
+    if (!(lastEvent == rhs.lastEvent))
+      return false;
+    if (__isset.maxEvents != rhs.__isset.maxEvents)
+      return false;
+    else if (__isset.maxEvents && !(maxEvents == rhs.maxEvents))
+      return false;
+    return true;
+  }
+  bool operator != (const NotificationEventRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const NotificationEventRequest & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(NotificationEventRequest &a, NotificationEventRequest &b);
+
+typedef struct _NotificationEvent__isset {
+  _NotificationEvent__isset() : dbName(false), tableName(false) {}
+  bool dbName;
+  bool tableName;
+} _NotificationEvent__isset;
+
+class NotificationEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "ACAF0036D9999F3A389F490F5E22D369";
+  static const uint8_t binary_fingerprint[16]; // = {0xAC,0xAF,0x00,0x36,0xD9,0x99,0x9F,0x3A,0x38,0x9F,0x49,0x0F,0x5E,0x22,0xD3,0x69};
+
+  NotificationEvent() : eventId(0), eventTime(0), eventType(), dbName(), tableName(), message() {
+  }
+
+  virtual ~NotificationEvent() throw() {}
+
+  int64_t eventId;
+  int32_t eventTime;
+  std::string eventType;
+  std::string dbName;
+  std::string tableName;
+  std::string message;
+
+  _NotificationEvent__isset __isset;
+
+  void __set_eventId(const int64_t val) {
+    eventId = val;
+  }
+
+  void __set_eventTime(const int32_t val) {
+    eventTime = val;
+  }
+
+  void __set_eventType(const std::string& val) {
+    eventType = val;
+  }
+
+  void __set_dbName(const std::string& val) {
+    dbName = val;
+    __isset.dbName = true;
+  }
+
+  void __set_tableName(const std::string& val) {
+    tableName = val;
+    __isset.tableName = true;
+  }
+
+  void __set_message(const std::string& val) {
+    message = val;
+  }
+
+  bool operator == (const NotificationEvent & rhs) const
+  {
+    if (!(eventId == rhs.eventId))
+      return false;
+    if (!(eventTime == rhs.eventTime))
+      return false;
+    if (!(eventType == rhs.eventType))
+      return false;
+    if (__isset.dbName != rhs.__isset.dbName)
+      return false;
+    else if (__isset.dbName && !(dbName == rhs.dbName))
+      return false;
+    if (__isset.tableName != rhs.__isset.tableName)
+      return false;
+    else if (__isset.tableName && !(tableName == rhs.tableName))
+      return false;
+    if (!(message == rhs.message))
+      return false;
+    return true;
+  }
+  bool operator != (const NotificationEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const NotificationEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(NotificationEvent &a, NotificationEvent &b);
+
+
+class NotificationEventResponse {
+ public:
+
+  static const char* ascii_fingerprint; // = "EE3DB23399639114BCD1782A0FB01818";
+  static const uint8_t binary_fingerprint[16]; // = {0xEE,0x3D,0xB2,0x33,0x99,0x63,0x91,0x14,0xBC,0xD1,0x78,0x2A,0x0F,0xB0,0x18,0x18};
+
+  NotificationEventResponse() {
+  }
+
+  virtual ~NotificationEventResponse() throw() {}
+
+  std::vector<NotificationEvent>  events;
+
+  void __set_events(const std::vector<NotificationEvent> & val) {
+    events = val;
+  }
+
+  bool operator == (const NotificationEventResponse & rhs) const
+  {
+    if (!(events == rhs.events))
+      return false;
+    return true;
+  }
+  bool operator != (const NotificationEventResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const NotificationEventResponse & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(NotificationEventResponse &a, NotificationEventResponse &b);
+
+
+class CurrentNotificationEventId {
+ public:
+
+  static const char* ascii_fingerprint; // = "56A59CE7FFAF82BCA8A19FAACDE4FB75";
+  static const uint8_t binary_fingerprint[16]; // = {0x56,0xA5,0x9C,0xE7,0xFF,0xAF,0x82,0xBC,0xA8,0xA1,0x9F,0xAA,0xCD,0xE4,0xFB,0x75};
+
+  CurrentNotificationEventId() : eventId(0) {
+  }
+
+  virtual ~CurrentNotificationEventId() throw() {}
+
+  int64_t eventId;
+
+  void __set_eventId(const int64_t val) {
+    eventId = val;
+  }
+
+  bool operator == (const CurrentNotificationEventId & rhs) const
+  {
+    if (!(eventId == rhs.eventId))
+      return false;
+    return true;
+  }
+  bool operator != (const CurrentNotificationEventId &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const CurrentNotificationEventId & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b);
+
 typedef struct _MetaException__isset {
   _MetaException__isset() : message(false) {}
   bool message;

Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java?rev=1650145&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java Wed Jan  7 20:15:10 2015
@@ -0,0 +1,383 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+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;
+
+public class CurrentNotificationEventId implements org.apache.thrift.TBase<CurrentNotificationEventId, CurrentNotificationEventId._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("CurrentNotificationEventId");
+
+  private static final org.apache.thrift.protocol.TField EVENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("eventId", org.apache.thrift.protocol.TType.I64, (short)1);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new CurrentNotificationEventIdStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new CurrentNotificationEventIdTupleSchemeFactory());
+  }
+
+  private long eventId; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    EVENT_ID((short)1, "eventId");
+
+    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: // EVENT_ID
+          return EVENT_ID;
+        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
+  private static final int __EVENTID_ISSET_ID = 0;
+  private byte __isset_bitfield = 0;
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.EVENT_ID, new org.apache.thrift.meta_data.FieldMetaData("eventId", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CurrentNotificationEventId.class, metaDataMap);
+  }
+
+  public CurrentNotificationEventId() {
+  }
+
+  public CurrentNotificationEventId(
+    long eventId)
+  {
+    this();
+    this.eventId = eventId;
+    setEventIdIsSet(true);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public CurrentNotificationEventId(CurrentNotificationEventId other) {
+    __isset_bitfield = other.__isset_bitfield;
+    this.eventId = other.eventId;
+  }
+
+  public CurrentNotificationEventId deepCopy() {
+    return new CurrentNotificationEventId(this);
+  }
+
+  @Override
+  public void clear() {
+    setEventIdIsSet(false);
+    this.eventId = 0;
+  }
+
+  public long getEventId() {
+    return this.eventId;
+  }
+
+  public void setEventId(long eventId) {
+    this.eventId = eventId;
+    setEventIdIsSet(true);
+  }
+
+  public void unsetEventId() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EVENTID_ISSET_ID);
+  }
+
+  /** Returns true if field eventId is set (has been assigned a value) and false otherwise */
+  public boolean isSetEventId() {
+    return EncodingUtils.testBit(__isset_bitfield, __EVENTID_ISSET_ID);
+  }
+
+  public void setEventIdIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EVENTID_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case EVENT_ID:
+      if (value == null) {
+        unsetEventId();
+      } else {
+        setEventId((Long)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case EVENT_ID:
+      return Long.valueOf(getEventId());
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case EVENT_ID:
+      return isSetEventId();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof CurrentNotificationEventId)
+      return this.equals((CurrentNotificationEventId)that);
+    return false;
+  }
+
+  public boolean equals(CurrentNotificationEventId that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_eventId = true;
+    boolean that_present_eventId = true;
+    if (this_present_eventId || that_present_eventId) {
+      if (!(this_present_eventId && that_present_eventId))
+        return false;
+      if (this.eventId != that.eventId)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    HashCodeBuilder builder = new HashCodeBuilder();
+
+    boolean present_eventId = true;
+    builder.append(present_eventId);
+    if (present_eventId)
+      builder.append(eventId);
+
+    return builder.toHashCode();
+  }
+
+  public int compareTo(CurrentNotificationEventId other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    CurrentNotificationEventId typedOther = (CurrentNotificationEventId)other;
+
+    lastComparison = Boolean.valueOf(isSetEventId()).compareTo(typedOther.isSetEventId());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetEventId()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventId, typedOther.eventId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("CurrentNotificationEventId(");
+    boolean first = true;
+
+    sb.append("eventId:");
+    sb.append(this.eventId);
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    if (!isSetEventId()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventId' is unset! Struct:" + toString());
+    }
+
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class CurrentNotificationEventIdStandardSchemeFactory implements SchemeFactory {
+    public CurrentNotificationEventIdStandardScheme getScheme() {
+      return new CurrentNotificationEventIdStandardScheme();
+    }
+  }
+
+  private static class CurrentNotificationEventIdStandardScheme extends StandardScheme<CurrentNotificationEventId> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, CurrentNotificationEventId struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // EVENT_ID
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.eventId = iprot.readI64();
+              struct.setEventIdIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, CurrentNotificationEventId struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(EVENT_ID_FIELD_DESC);
+      oprot.writeI64(struct.eventId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class CurrentNotificationEventIdTupleSchemeFactory implements SchemeFactory {
+    public CurrentNotificationEventIdTupleScheme getScheme() {
+      return new CurrentNotificationEventIdTupleScheme();
+    }
+  }
+
+  private static class CurrentNotificationEventIdTupleScheme extends TupleScheme<CurrentNotificationEventId> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, CurrentNotificationEventId struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      oprot.writeI64(struct.eventId);
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, CurrentNotificationEventId struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.eventId = iprot.readI64();
+      struct.setEventIdIsSet(true);
+    }
+  }
+
+}
+

Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java?rev=1650145&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java Wed Jan  7 20:15:10 2015
@@ -0,0 +1,896 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+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;
+
+public class NotificationEvent implements org.apache.thrift.TBase<NotificationEvent, NotificationEvent._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("NotificationEvent");
+
+  private static final org.apache.thrift.protocol.TField EVENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("eventId", org.apache.thrift.protocol.TType.I64, (short)1);
+  private static final org.apache.thrift.protocol.TField EVENT_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("eventTime", org.apache.thrift.protocol.TType.I32, (short)2);
+  private static final org.apache.thrift.protocol.TField EVENT_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("eventType", org.apache.thrift.protocol.TType.STRING, (short)3);
+  private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbName", org.apache.thrift.protocol.TType.STRING, (short)4);
+  private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)5);
+  private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)6);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new NotificationEventStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new NotificationEventTupleSchemeFactory());
+  }
+
+  private long eventId; // required
+  private int eventTime; // required
+  private String eventType; // required
+  private String dbName; // optional
+  private String tableName; // optional
+  private String message; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    EVENT_ID((short)1, "eventId"),
+    EVENT_TIME((short)2, "eventTime"),
+    EVENT_TYPE((short)3, "eventType"),
+    DB_NAME((short)4, "dbName"),
+    TABLE_NAME((short)5, "tableName"),
+    MESSAGE((short)6, "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: // EVENT_ID
+          return EVENT_ID;
+        case 2: // EVENT_TIME
+          return EVENT_TIME;
+        case 3: // EVENT_TYPE
+          return EVENT_TYPE;
+        case 4: // DB_NAME
+          return DB_NAME;
+        case 5: // TABLE_NAME
+          return TABLE_NAME;
+        case 6: // 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
+  private static final int __EVENTID_ISSET_ID = 0;
+  private static final int __EVENTTIME_ISSET_ID = 1;
+  private byte __isset_bitfield = 0;
+  private _Fields optionals[] = {_Fields.DB_NAME,_Fields.TABLE_NAME};
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.EVENT_ID, new org.apache.thrift.meta_data.FieldMetaData("eventId", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.EVENT_TIME, new org.apache.thrift.meta_data.FieldMetaData("eventTime", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.EVENT_TYPE, new org.apache.thrift.meta_data.FieldMetaData("eventType", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("dbName", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(NotificationEvent.class, metaDataMap);
+  }
+
+  public NotificationEvent() {
+  }
+
+  public NotificationEvent(
+    long eventId,
+    int eventTime,
+    String eventType,
+    String message)
+  {
+    this();
+    this.eventId = eventId;
+    setEventIdIsSet(true);
+    this.eventTime = eventTime;
+    setEventTimeIsSet(true);
+    this.eventType = eventType;
+    this.message = message;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public NotificationEvent(NotificationEvent other) {
+    __isset_bitfield = other.__isset_bitfield;
+    this.eventId = other.eventId;
+    this.eventTime = other.eventTime;
+    if (other.isSetEventType()) {
+      this.eventType = other.eventType;
+    }
+    if (other.isSetDbName()) {
+      this.dbName = other.dbName;
+    }
+    if (other.isSetTableName()) {
+      this.tableName = other.tableName;
+    }
+    if (other.isSetMessage()) {
+      this.message = other.message;
+    }
+  }
+
+  public NotificationEvent deepCopy() {
+    return new NotificationEvent(this);
+  }
+
+  @Override
+  public void clear() {
+    setEventIdIsSet(false);
+    this.eventId = 0;
+    setEventTimeIsSet(false);
+    this.eventTime = 0;
+    this.eventType = null;
+    this.dbName = null;
+    this.tableName = null;
+    this.message = null;
+  }
+
+  public long getEventId() {
+    return this.eventId;
+  }
+
+  public void setEventId(long eventId) {
+    this.eventId = eventId;
+    setEventIdIsSet(true);
+  }
+
+  public void unsetEventId() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EVENTID_ISSET_ID);
+  }
+
+  /** Returns true if field eventId is set (has been assigned a value) and false otherwise */
+  public boolean isSetEventId() {
+    return EncodingUtils.testBit(__isset_bitfield, __EVENTID_ISSET_ID);
+  }
+
+  public void setEventIdIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EVENTID_ISSET_ID, value);
+  }
+
+  public int getEventTime() {
+    return this.eventTime;
+  }
+
+  public void setEventTime(int eventTime) {
+    this.eventTime = eventTime;
+    setEventTimeIsSet(true);
+  }
+
+  public void unsetEventTime() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EVENTTIME_ISSET_ID);
+  }
+
+  /** Returns true if field eventTime is set (has been assigned a value) and false otherwise */
+  public boolean isSetEventTime() {
+    return EncodingUtils.testBit(__isset_bitfield, __EVENTTIME_ISSET_ID);
+  }
+
+  public void setEventTimeIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EVENTTIME_ISSET_ID, value);
+  }
+
+  public String getEventType() {
+    return this.eventType;
+  }
+
+  public void setEventType(String eventType) {
+    this.eventType = eventType;
+  }
+
+  public void unsetEventType() {
+    this.eventType = null;
+  }
+
+  /** Returns true if field eventType is set (has been assigned a value) and false otherwise */
+  public boolean isSetEventType() {
+    return this.eventType != null;
+  }
+
+  public void setEventTypeIsSet(boolean value) {
+    if (!value) {
+      this.eventType = null;
+    }
+  }
+
+  public String getDbName() {
+    return this.dbName;
+  }
+
+  public void setDbName(String dbName) {
+    this.dbName = dbName;
+  }
+
+  public void unsetDbName() {
+    this.dbName = null;
+  }
+
+  /** Returns true if field dbName is set (has been assigned a value) and false otherwise */
+  public boolean isSetDbName() {
+    return this.dbName != null;
+  }
+
+  public void setDbNameIsSet(boolean value) {
+    if (!value) {
+      this.dbName = null;
+    }
+  }
+
+  public String getTableName() {
+    return this.tableName;
+  }
+
+  public void setTableName(String tableName) {
+    this.tableName = tableName;
+  }
+
+  public void unsetTableName() {
+    this.tableName = null;
+  }
+
+  /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+  public boolean isSetTableName() {
+    return this.tableName != null;
+  }
+
+  public void setTableNameIsSet(boolean value) {
+    if (!value) {
+      this.tableName = 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 assigned 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 EVENT_ID:
+      if (value == null) {
+        unsetEventId();
+      } else {
+        setEventId((Long)value);
+      }
+      break;
+
+    case EVENT_TIME:
+      if (value == null) {
+        unsetEventTime();
+      } else {
+        setEventTime((Integer)value);
+      }
+      break;
+
+    case EVENT_TYPE:
+      if (value == null) {
+        unsetEventType();
+      } else {
+        setEventType((String)value);
+      }
+      break;
+
+    case DB_NAME:
+      if (value == null) {
+        unsetDbName();
+      } else {
+        setDbName((String)value);
+      }
+      break;
+
+    case TABLE_NAME:
+      if (value == null) {
+        unsetTableName();
+      } else {
+        setTableName((String)value);
+      }
+      break;
+
+    case MESSAGE:
+      if (value == null) {
+        unsetMessage();
+      } else {
+        setMessage((String)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case EVENT_ID:
+      return Long.valueOf(getEventId());
+
+    case EVENT_TIME:
+      return Integer.valueOf(getEventTime());
+
+    case EVENT_TYPE:
+      return getEventType();
+
+    case DB_NAME:
+      return getDbName();
+
+    case TABLE_NAME:
+      return getTableName();
+
+    case MESSAGE:
+      return getMessage();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case EVENT_ID:
+      return isSetEventId();
+    case EVENT_TIME:
+      return isSetEventTime();
+    case EVENT_TYPE:
+      return isSetEventType();
+    case DB_NAME:
+      return isSetDbName();
+    case TABLE_NAME:
+      return isSetTableName();
+    case MESSAGE:
+      return isSetMessage();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof NotificationEvent)
+      return this.equals((NotificationEvent)that);
+    return false;
+  }
+
+  public boolean equals(NotificationEvent that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_eventId = true;
+    boolean that_present_eventId = true;
+    if (this_present_eventId || that_present_eventId) {
+      if (!(this_present_eventId && that_present_eventId))
+        return false;
+      if (this.eventId != that.eventId)
+        return false;
+    }
+
+    boolean this_present_eventTime = true;
+    boolean that_present_eventTime = true;
+    if (this_present_eventTime || that_present_eventTime) {
+      if (!(this_present_eventTime && that_present_eventTime))
+        return false;
+      if (this.eventTime != that.eventTime)
+        return false;
+    }
+
+    boolean this_present_eventType = true && this.isSetEventType();
+    boolean that_present_eventType = true && that.isSetEventType();
+    if (this_present_eventType || that_present_eventType) {
+      if (!(this_present_eventType && that_present_eventType))
+        return false;
+      if (!this.eventType.equals(that.eventType))
+        return false;
+    }
+
+    boolean this_present_dbName = true && this.isSetDbName();
+    boolean that_present_dbName = true && that.isSetDbName();
+    if (this_present_dbName || that_present_dbName) {
+      if (!(this_present_dbName && that_present_dbName))
+        return false;
+      if (!this.dbName.equals(that.dbName))
+        return false;
+    }
+
+    boolean this_present_tableName = true && this.isSetTableName();
+    boolean that_present_tableName = true && that.isSetTableName();
+    if (this_present_tableName || that_present_tableName) {
+      if (!(this_present_tableName && that_present_tableName))
+        return false;
+      if (!this.tableName.equals(that.tableName))
+        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() {
+    HashCodeBuilder builder = new HashCodeBuilder();
+
+    boolean present_eventId = true;
+    builder.append(present_eventId);
+    if (present_eventId)
+      builder.append(eventId);
+
+    boolean present_eventTime = true;
+    builder.append(present_eventTime);
+    if (present_eventTime)
+      builder.append(eventTime);
+
+    boolean present_eventType = true && (isSetEventType());
+    builder.append(present_eventType);
+    if (present_eventType)
+      builder.append(eventType);
+
+    boolean present_dbName = true && (isSetDbName());
+    builder.append(present_dbName);
+    if (present_dbName)
+      builder.append(dbName);
+
+    boolean present_tableName = true && (isSetTableName());
+    builder.append(present_tableName);
+    if (present_tableName)
+      builder.append(tableName);
+
+    boolean present_message = true && (isSetMessage());
+    builder.append(present_message);
+    if (present_message)
+      builder.append(message);
+
+    return builder.toHashCode();
+  }
+
+  public int compareTo(NotificationEvent other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    NotificationEvent typedOther = (NotificationEvent)other;
+
+    lastComparison = Boolean.valueOf(isSetEventId()).compareTo(typedOther.isSetEventId());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetEventId()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventId, typedOther.eventId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetEventTime()).compareTo(typedOther.isSetEventTime());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetEventTime()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventTime, typedOther.eventTime);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetEventType()).compareTo(typedOther.isSetEventType());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetEventType()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventType, typedOther.eventType);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetDbName()).compareTo(typedOther.isSetDbName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetDbName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbName, typedOther.dbName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetTableName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetMessage()).compareTo(typedOther.isSetMessage());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMessage()) {
+      lastComparison = org.apache.thrift.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(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("NotificationEvent(");
+    boolean first = true;
+
+    sb.append("eventId:");
+    sb.append(this.eventId);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("eventTime:");
+    sb.append(this.eventTime);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("eventType:");
+    if (this.eventType == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.eventType);
+    }
+    first = false;
+    if (isSetDbName()) {
+      if (!first) sb.append(", ");
+      sb.append("dbName:");
+      if (this.dbName == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.dbName);
+      }
+      first = false;
+    }
+    if (isSetTableName()) {
+      if (!first) sb.append(", ");
+      sb.append("tableName:");
+      if (this.tableName == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.tableName);
+      }
+      first = false;
+    }
+    if (!first) sb.append(", ");
+    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 org.apache.thrift.TException {
+    // check for required fields
+    if (!isSetEventId()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventId' is unset! Struct:" + toString());
+    }
+
+    if (!isSetEventTime()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventTime' is unset! Struct:" + toString());
+    }
+
+    if (!isSetEventType()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventType' is unset! Struct:" + toString());
+    }
+
+    if (!isSetMessage()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'message' is unset! Struct:" + toString());
+    }
+
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class NotificationEventStandardSchemeFactory implements SchemeFactory {
+    public NotificationEventStandardScheme getScheme() {
+      return new NotificationEventStandardScheme();
+    }
+  }
+
+  private static class NotificationEventStandardScheme extends StandardScheme<NotificationEvent> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, NotificationEvent struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // EVENT_ID
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.eventId = iprot.readI64();
+              struct.setEventIdIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // EVENT_TIME
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.eventTime = iprot.readI32();
+              struct.setEventTimeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // EVENT_TYPE
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.eventType = iprot.readString();
+              struct.setEventTypeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 4: // DB_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.dbName = iprot.readString();
+              struct.setDbNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 5: // TABLE_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.tableName = iprot.readString();
+              struct.setTableNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 6: // MESSAGE
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.message = iprot.readString();
+              struct.setMessageIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, NotificationEvent struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(EVENT_ID_FIELD_DESC);
+      oprot.writeI64(struct.eventId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(EVENT_TIME_FIELD_DESC);
+      oprot.writeI32(struct.eventTime);
+      oprot.writeFieldEnd();
+      if (struct.eventType != null) {
+        oprot.writeFieldBegin(EVENT_TYPE_FIELD_DESC);
+        oprot.writeString(struct.eventType);
+        oprot.writeFieldEnd();
+      }
+      if (struct.dbName != null) {
+        if (struct.isSetDbName()) {
+          oprot.writeFieldBegin(DB_NAME_FIELD_DESC);
+          oprot.writeString(struct.dbName);
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.tableName != null) {
+        if (struct.isSetTableName()) {
+          oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+          oprot.writeString(struct.tableName);
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.message != null) {
+        oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+        oprot.writeString(struct.message);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class NotificationEventTupleSchemeFactory implements SchemeFactory {
+    public NotificationEventTupleScheme getScheme() {
+      return new NotificationEventTupleScheme();
+    }
+  }
+
+  private static class NotificationEventTupleScheme extends TupleScheme<NotificationEvent> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, NotificationEvent struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      oprot.writeI64(struct.eventId);
+      oprot.writeI32(struct.eventTime);
+      oprot.writeString(struct.eventType);
+      oprot.writeString(struct.message);
+      BitSet optionals = new BitSet();
+      if (struct.isSetDbName()) {
+        optionals.set(0);
+      }
+      if (struct.isSetTableName()) {
+        optionals.set(1);
+      }
+      oprot.writeBitSet(optionals, 2);
+      if (struct.isSetDbName()) {
+        oprot.writeString(struct.dbName);
+      }
+      if (struct.isSetTableName()) {
+        oprot.writeString(struct.tableName);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, NotificationEvent struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.eventId = iprot.readI64();
+      struct.setEventIdIsSet(true);
+      struct.eventTime = iprot.readI32();
+      struct.setEventTimeIsSet(true);
+      struct.eventType = iprot.readString();
+      struct.setEventTypeIsSet(true);
+      struct.message = iprot.readString();
+      struct.setMessageIsSet(true);
+      BitSet incoming = iprot.readBitSet(2);
+      if (incoming.get(0)) {
+        struct.dbName = iprot.readString();
+        struct.setDbNameIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.tableName = iprot.readString();
+        struct.setTableNameIsSet(true);
+      }
+    }
+  }
+
+}
+



Mime
View raw message