hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ser...@apache.org
Subject [12/14] hive git commit: HIVE-11552 : implement basic methods for getting/putting file metadata (Sergey Shelukhin, reviewed by Alan Gates)
Date Mon, 24 Aug 2015 19:22:34 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/129bed52/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
index baa28e3..49d31e6 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
@@ -141,6 +141,10 @@ class ThriftHiveMetastoreIf : virtual public  ::facebook::fb303::FacebookService
   virtual void get_current_notificationEventId(CurrentNotificationEventId& _return) = 0;
   virtual void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) = 0;
   virtual void flushCache() = 0;
+  virtual void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) = 0;
+  virtual void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) = 0;
+  virtual void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) = 0;
+  virtual void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) = 0;
 };
 
 class ThriftHiveMetastoreIfFactory : virtual public  ::facebook::fb303::FacebookServiceIfFactory {
@@ -568,6 +572,18 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p
   void flushCache() {
     return;
   }
+  void get_file_metadata_by_expr(GetFileMetadataByExprResult& /* _return */, const GetFileMetadataByExprRequest& /* req */) {
+    return;
+  }
+  void get_file_metadata(GetFileMetadataResult& /* _return */, const GetFileMetadataRequest& /* req */) {
+    return;
+  }
+  void put_file_metadata(PutFileMetadataResult& /* _return */, const PutFileMetadataRequest& /* req */) {
+    return;
+  }
+  void clear_file_metadata(ClearFileMetadataResult& /* _return */, const ClearFileMetadataRequest& /* req */) {
+    return;
+  }
 };
 
 typedef struct _ThriftHiveMetastore_getMetaConf_args__isset {
@@ -18287,6 +18303,486 @@ class ThriftHiveMetastore_flushCache_presult {
   friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_flushCache_presult& obj);
 };
 
+typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset {
+  _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset() : req(false) {}
+  bool req :1;
+} _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset;
+
+class ThriftHiveMetastore_get_file_metadata_by_expr_args {
+ public:
+
+  static const char* ascii_fingerprint; // = "35F3A2DA650F5293300EA6DB58284F86";
+  static const uint8_t binary_fingerprint[16]; // = {0x35,0xF3,0xA2,0xDA,0x65,0x0F,0x52,0x93,0x30,0x0E,0xA6,0xDB,0x58,0x28,0x4F,0x86};
+
+  ThriftHiveMetastore_get_file_metadata_by_expr_args(const ThriftHiveMetastore_get_file_metadata_by_expr_args&);
+  ThriftHiveMetastore_get_file_metadata_by_expr_args& operator=(const ThriftHiveMetastore_get_file_metadata_by_expr_args&);
+  ThriftHiveMetastore_get_file_metadata_by_expr_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_args() throw();
+  GetFileMetadataByExprRequest req;
+
+  _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset __isset;
+
+  void __set_req(const GetFileMetadataByExprRequest& val);
+
+  bool operator == (const ThriftHiveMetastore_get_file_metadata_by_expr_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_file_metadata_by_expr_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_file_metadata_by_expr_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_by_expr_args& obj);
+};
+
+
+class ThriftHiveMetastore_get_file_metadata_by_expr_pargs {
+ public:
+
+  static const char* ascii_fingerprint; // = "35F3A2DA650F5293300EA6DB58284F86";
+  static const uint8_t binary_fingerprint[16]; // = {0x35,0xF3,0xA2,0xDA,0x65,0x0F,0x52,0x93,0x30,0x0E,0xA6,0xDB,0x58,0x28,0x4F,0x86};
+
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_pargs() throw();
+  const GetFileMetadataByExprRequest* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_by_expr_pargs& obj);
+};
+
+typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset {
+  _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset;
+
+class ThriftHiveMetastore_get_file_metadata_by_expr_result {
+ public:
+
+  static const char* ascii_fingerprint; // = "E2053E1FBA55841322D49B2FBE16E310";
+  static const uint8_t binary_fingerprint[16]; // = {0xE2,0x05,0x3E,0x1F,0xBA,0x55,0x84,0x13,0x22,0xD4,0x9B,0x2F,0xBE,0x16,0xE3,0x10};
+
+  ThriftHiveMetastore_get_file_metadata_by_expr_result(const ThriftHiveMetastore_get_file_metadata_by_expr_result&);
+  ThriftHiveMetastore_get_file_metadata_by_expr_result& operator=(const ThriftHiveMetastore_get_file_metadata_by_expr_result&);
+  ThriftHiveMetastore_get_file_metadata_by_expr_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_result() throw();
+  GetFileMetadataByExprResult success;
+
+  _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset __isset;
+
+  void __set_success(const GetFileMetadataByExprResult& val);
+
+  bool operator == (const ThriftHiveMetastore_get_file_metadata_by_expr_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_file_metadata_by_expr_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_file_metadata_by_expr_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_by_expr_result& obj);
+};
+
+typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset {
+  _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset;
+
+class ThriftHiveMetastore_get_file_metadata_by_expr_presult {
+ public:
+
+  static const char* ascii_fingerprint; // = "E2053E1FBA55841322D49B2FBE16E310";
+  static const uint8_t binary_fingerprint[16]; // = {0xE2,0x05,0x3E,0x1F,0xBA,0x55,0x84,0x13,0x22,0xD4,0x9B,0x2F,0xBE,0x16,0xE3,0x10};
+
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_presult() throw();
+  GetFileMetadataByExprResult* success;
+
+  _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_by_expr_presult& obj);
+};
+
+typedef struct _ThriftHiveMetastore_get_file_metadata_args__isset {
+  _ThriftHiveMetastore_get_file_metadata_args__isset() : req(false) {}
+  bool req :1;
+} _ThriftHiveMetastore_get_file_metadata_args__isset;
+
+class ThriftHiveMetastore_get_file_metadata_args {
+ public:
+
+  static const char* ascii_fingerprint; // = "1BC0267F37F033AE9EEA2EB33C70733E";
+  static const uint8_t binary_fingerprint[16]; // = {0x1B,0xC0,0x26,0x7F,0x37,0xF0,0x33,0xAE,0x9E,0xEA,0x2E,0xB3,0x3C,0x70,0x73,0x3E};
+
+  ThriftHiveMetastore_get_file_metadata_args(const ThriftHiveMetastore_get_file_metadata_args&);
+  ThriftHiveMetastore_get_file_metadata_args& operator=(const ThriftHiveMetastore_get_file_metadata_args&);
+  ThriftHiveMetastore_get_file_metadata_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_args() throw();
+  GetFileMetadataRequest req;
+
+  _ThriftHiveMetastore_get_file_metadata_args__isset __isset;
+
+  void __set_req(const GetFileMetadataRequest& val);
+
+  bool operator == (const ThriftHiveMetastore_get_file_metadata_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_file_metadata_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_file_metadata_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_args& obj);
+};
+
+
+class ThriftHiveMetastore_get_file_metadata_pargs {
+ public:
+
+  static const char* ascii_fingerprint; // = "1BC0267F37F033AE9EEA2EB33C70733E";
+  static const uint8_t binary_fingerprint[16]; // = {0x1B,0xC0,0x26,0x7F,0x37,0xF0,0x33,0xAE,0x9E,0xEA,0x2E,0xB3,0x3C,0x70,0x73,0x3E};
+
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_pargs() throw();
+  const GetFileMetadataRequest* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_pargs& obj);
+};
+
+typedef struct _ThriftHiveMetastore_get_file_metadata_result__isset {
+  _ThriftHiveMetastore_get_file_metadata_result__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_file_metadata_result__isset;
+
+class ThriftHiveMetastore_get_file_metadata_result {
+ public:
+
+  static const char* ascii_fingerprint; // = "2E68003888122322D29FD7969DAE8C2A";
+  static const uint8_t binary_fingerprint[16]; // = {0x2E,0x68,0x00,0x38,0x88,0x12,0x23,0x22,0xD2,0x9F,0xD7,0x96,0x9D,0xAE,0x8C,0x2A};
+
+  ThriftHiveMetastore_get_file_metadata_result(const ThriftHiveMetastore_get_file_metadata_result&);
+  ThriftHiveMetastore_get_file_metadata_result& operator=(const ThriftHiveMetastore_get_file_metadata_result&);
+  ThriftHiveMetastore_get_file_metadata_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_result() throw();
+  GetFileMetadataResult success;
+
+  _ThriftHiveMetastore_get_file_metadata_result__isset __isset;
+
+  void __set_success(const GetFileMetadataResult& val);
+
+  bool operator == (const ThriftHiveMetastore_get_file_metadata_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_file_metadata_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_file_metadata_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_result& obj);
+};
+
+typedef struct _ThriftHiveMetastore_get_file_metadata_presult__isset {
+  _ThriftHiveMetastore_get_file_metadata_presult__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_file_metadata_presult__isset;
+
+class ThriftHiveMetastore_get_file_metadata_presult {
+ public:
+
+  static const char* ascii_fingerprint; // = "2E68003888122322D29FD7969DAE8C2A";
+  static const uint8_t binary_fingerprint[16]; // = {0x2E,0x68,0x00,0x38,0x88,0x12,0x23,0x22,0xD2,0x9F,0xD7,0x96,0x9D,0xAE,0x8C,0x2A};
+
+
+  virtual ~ThriftHiveMetastore_get_file_metadata_presult() throw();
+  GetFileMetadataResult* success;
+
+  _ThriftHiveMetastore_get_file_metadata_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_get_file_metadata_presult& obj);
+};
+
+typedef struct _ThriftHiveMetastore_put_file_metadata_args__isset {
+  _ThriftHiveMetastore_put_file_metadata_args__isset() : req(false) {}
+  bool req :1;
+} _ThriftHiveMetastore_put_file_metadata_args__isset;
+
+class ThriftHiveMetastore_put_file_metadata_args {
+ public:
+
+  static const char* ascii_fingerprint; // = "CC8035DE851F68540899C9E7BDA51238";
+  static const uint8_t binary_fingerprint[16]; // = {0xCC,0x80,0x35,0xDE,0x85,0x1F,0x68,0x54,0x08,0x99,0xC9,0xE7,0xBD,0xA5,0x12,0x38};
+
+  ThriftHiveMetastore_put_file_metadata_args(const ThriftHiveMetastore_put_file_metadata_args&);
+  ThriftHiveMetastore_put_file_metadata_args& operator=(const ThriftHiveMetastore_put_file_metadata_args&);
+  ThriftHiveMetastore_put_file_metadata_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_put_file_metadata_args() throw();
+  PutFileMetadataRequest req;
+
+  _ThriftHiveMetastore_put_file_metadata_args__isset __isset;
+
+  void __set_req(const PutFileMetadataRequest& val);
+
+  bool operator == (const ThriftHiveMetastore_put_file_metadata_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_put_file_metadata_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_put_file_metadata_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_put_file_metadata_args& obj);
+};
+
+
+class ThriftHiveMetastore_put_file_metadata_pargs {
+ public:
+
+  static const char* ascii_fingerprint; // = "CC8035DE851F68540899C9E7BDA51238";
+  static const uint8_t binary_fingerprint[16]; // = {0xCC,0x80,0x35,0xDE,0x85,0x1F,0x68,0x54,0x08,0x99,0xC9,0xE7,0xBD,0xA5,0x12,0x38};
+
+
+  virtual ~ThriftHiveMetastore_put_file_metadata_pargs() throw();
+  const PutFileMetadataRequest* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_put_file_metadata_pargs& obj);
+};
+
+typedef struct _ThriftHiveMetastore_put_file_metadata_result__isset {
+  _ThriftHiveMetastore_put_file_metadata_result__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_put_file_metadata_result__isset;
+
+class ThriftHiveMetastore_put_file_metadata_result {
+ public:
+
+  static const char* ascii_fingerprint; // = "3A26B8DD823AB72F2FE94404F3D36070";
+  static const uint8_t binary_fingerprint[16]; // = {0x3A,0x26,0xB8,0xDD,0x82,0x3A,0xB7,0x2F,0x2F,0xE9,0x44,0x04,0xF3,0xD3,0x60,0x70};
+
+  ThriftHiveMetastore_put_file_metadata_result(const ThriftHiveMetastore_put_file_metadata_result&);
+  ThriftHiveMetastore_put_file_metadata_result& operator=(const ThriftHiveMetastore_put_file_metadata_result&);
+  ThriftHiveMetastore_put_file_metadata_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_put_file_metadata_result() throw();
+  PutFileMetadataResult success;
+
+  _ThriftHiveMetastore_put_file_metadata_result__isset __isset;
+
+  void __set_success(const PutFileMetadataResult& val);
+
+  bool operator == (const ThriftHiveMetastore_put_file_metadata_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_put_file_metadata_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_put_file_metadata_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_put_file_metadata_result& obj);
+};
+
+typedef struct _ThriftHiveMetastore_put_file_metadata_presult__isset {
+  _ThriftHiveMetastore_put_file_metadata_presult__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_put_file_metadata_presult__isset;
+
+class ThriftHiveMetastore_put_file_metadata_presult {
+ public:
+
+  static const char* ascii_fingerprint; // = "3A26B8DD823AB72F2FE94404F3D36070";
+  static const uint8_t binary_fingerprint[16]; // = {0x3A,0x26,0xB8,0xDD,0x82,0x3A,0xB7,0x2F,0x2F,0xE9,0x44,0x04,0xF3,0xD3,0x60,0x70};
+
+
+  virtual ~ThriftHiveMetastore_put_file_metadata_presult() throw();
+  PutFileMetadataResult* success;
+
+  _ThriftHiveMetastore_put_file_metadata_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_put_file_metadata_presult& obj);
+};
+
+typedef struct _ThriftHiveMetastore_clear_file_metadata_args__isset {
+  _ThriftHiveMetastore_clear_file_metadata_args__isset() : req(false) {}
+  bool req :1;
+} _ThriftHiveMetastore_clear_file_metadata_args__isset;
+
+class ThriftHiveMetastore_clear_file_metadata_args {
+ public:
+
+  static const char* ascii_fingerprint; // = "1BC0267F37F033AE9EEA2EB33C70733E";
+  static const uint8_t binary_fingerprint[16]; // = {0x1B,0xC0,0x26,0x7F,0x37,0xF0,0x33,0xAE,0x9E,0xEA,0x2E,0xB3,0x3C,0x70,0x73,0x3E};
+
+  ThriftHiveMetastore_clear_file_metadata_args(const ThriftHiveMetastore_clear_file_metadata_args&);
+  ThriftHiveMetastore_clear_file_metadata_args& operator=(const ThriftHiveMetastore_clear_file_metadata_args&);
+  ThriftHiveMetastore_clear_file_metadata_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_clear_file_metadata_args() throw();
+  ClearFileMetadataRequest req;
+
+  _ThriftHiveMetastore_clear_file_metadata_args__isset __isset;
+
+  void __set_req(const ClearFileMetadataRequest& val);
+
+  bool operator == (const ThriftHiveMetastore_clear_file_metadata_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_clear_file_metadata_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_clear_file_metadata_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_clear_file_metadata_args& obj);
+};
+
+
+class ThriftHiveMetastore_clear_file_metadata_pargs {
+ public:
+
+  static const char* ascii_fingerprint; // = "1BC0267F37F033AE9EEA2EB33C70733E";
+  static const uint8_t binary_fingerprint[16]; // = {0x1B,0xC0,0x26,0x7F,0x37,0xF0,0x33,0xAE,0x9E,0xEA,0x2E,0xB3,0x3C,0x70,0x73,0x3E};
+
+
+  virtual ~ThriftHiveMetastore_clear_file_metadata_pargs() throw();
+  const ClearFileMetadataRequest* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_clear_file_metadata_pargs& obj);
+};
+
+typedef struct _ThriftHiveMetastore_clear_file_metadata_result__isset {
+  _ThriftHiveMetastore_clear_file_metadata_result__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_clear_file_metadata_result__isset;
+
+class ThriftHiveMetastore_clear_file_metadata_result {
+ public:
+
+  static const char* ascii_fingerprint; // = "3A26B8DD823AB72F2FE94404F3D36070";
+  static const uint8_t binary_fingerprint[16]; // = {0x3A,0x26,0xB8,0xDD,0x82,0x3A,0xB7,0x2F,0x2F,0xE9,0x44,0x04,0xF3,0xD3,0x60,0x70};
+
+  ThriftHiveMetastore_clear_file_metadata_result(const ThriftHiveMetastore_clear_file_metadata_result&);
+  ThriftHiveMetastore_clear_file_metadata_result& operator=(const ThriftHiveMetastore_clear_file_metadata_result&);
+  ThriftHiveMetastore_clear_file_metadata_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_clear_file_metadata_result() throw();
+  ClearFileMetadataResult success;
+
+  _ThriftHiveMetastore_clear_file_metadata_result__isset __isset;
+
+  void __set_success(const ClearFileMetadataResult& val);
+
+  bool operator == (const ThriftHiveMetastore_clear_file_metadata_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_clear_file_metadata_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_clear_file_metadata_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_clear_file_metadata_result& obj);
+};
+
+typedef struct _ThriftHiveMetastore_clear_file_metadata_presult__isset {
+  _ThriftHiveMetastore_clear_file_metadata_presult__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_clear_file_metadata_presult__isset;
+
+class ThriftHiveMetastore_clear_file_metadata_presult {
+ public:
+
+  static const char* ascii_fingerprint; // = "3A26B8DD823AB72F2FE94404F3D36070";
+  static const uint8_t binary_fingerprint[16]; // = {0x3A,0x26,0xB8,0xDD,0x82,0x3A,0xB7,0x2F,0x2F,0xE9,0x44,0x04,0xF3,0xD3,0x60,0x70};
+
+
+  virtual ~ThriftHiveMetastore_clear_file_metadata_presult() throw();
+  ClearFileMetadataResult* success;
+
+  _ThriftHiveMetastore_clear_file_metadata_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+  friend std::ostream& operator<<(std::ostream& out, const ThriftHiveMetastore_clear_file_metadata_presult& obj);
+};
+
 class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceClient {
  public:
   ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
@@ -18673,6 +19169,18 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public
   void flushCache();
   void send_flushCache();
   void recv_flushCache();
+  void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req);
+  void send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req);
+  void recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return);
+  void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req);
+  void send_get_file_metadata(const GetFileMetadataRequest& req);
+  void recv_get_file_metadata(GetFileMetadataResult& _return);
+  void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req);
+  void send_put_file_metadata(const PutFileMetadataRequest& req);
+  void recv_put_file_metadata(PutFileMetadataResult& _return);
+  void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req);
+  void send_clear_file_metadata(const ClearFileMetadataRequest& req);
+  void recv_clear_file_metadata(ClearFileMetadataResult& _return);
 };
 
 class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceProcessor {
@@ -18808,6 +19316,10 @@ class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceP
   void process_get_current_notificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_fire_listener_event(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_flushCache(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_file_metadata_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_put_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_clear_file_metadata(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),
@@ -18937,6 +19449,10 @@ class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceP
     processMap_["get_current_notificationEventId"] = &ThriftHiveMetastoreProcessor::process_get_current_notificationEventId;
     processMap_["fire_listener_event"] = &ThriftHiveMetastoreProcessor::process_fire_listener_event;
     processMap_["flushCache"] = &ThriftHiveMetastoreProcessor::process_flushCache;
+    processMap_["get_file_metadata_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata_by_expr;
+    processMap_["get_file_metadata"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata;
+    processMap_["put_file_metadata"] = &ThriftHiveMetastoreProcessor::process_put_file_metadata;
+    processMap_["clear_file_metadata"] = &ThriftHiveMetastoreProcessor::process_clear_file_metadata;
   }
 
   virtual ~ThriftHiveMetastoreProcessor() {}
@@ -20169,6 +20685,46 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi
     ifaces_[i]->flushCache();
   }
 
+  void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_file_metadata_by_expr(_return, req);
+    }
+    ifaces_[i]->get_file_metadata_by_expr(_return, req);
+    return;
+  }
+
+  void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_file_metadata(_return, req);
+    }
+    ifaces_[i]->get_file_metadata(_return, req);
+    return;
+  }
+
+  void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->put_file_metadata(_return, req);
+    }
+    ifaces_[i]->put_file_metadata(_return, req);
+    return;
+  }
+
+  void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->clear_file_metadata(_return, req);
+    }
+    ifaces_[i]->clear_file_metadata(_return, req);
+    return;
+  }
+
 };
 
 }}} // namespace

http://git-wip-us.apache.org/repos/asf/hive/blob/129bed52/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
index 339bc7d..9eca65c 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
@@ -647,6 +647,26 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf {
     printf("flushCache\n");
   }
 
+  void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) {
+    // Your implementation goes here
+    printf("get_file_metadata_by_expr\n");
+  }
+
+  void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) {
+    // Your implementation goes here
+    printf("get_file_metadata\n");
+  }
+
+  void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) {
+    // Your implementation goes here
+    printf("put_file_metadata\n");
+  }
+
+  void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) {
+    // Your implementation goes here
+    printf("clear_file_metadata\n");
+  }
+
 };
 
 int main(int argc, char **argv) {

http://git-wip-us.apache.org/repos/asf/hive/blob/129bed52/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 57c3477..e61ba1b 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -14373,6 +14373,1076 @@ std::ostream& operator<<(std::ostream& out, const FireEventResponse& obj) {
 }
 
 
+MetadataPpdResult::~MetadataPpdResult() throw() {
+}
+
+
+void MetadataPpdResult::__set_metadata(const std::string& val) {
+  this->metadata = val;
+}
+
+void MetadataPpdResult::__set_includeBitset(const std::string& val) {
+  this->includeBitset = val;
+}
+
+const char* MetadataPpdResult::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
+const uint8_t MetadataPpdResult::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+uint32_t MetadataPpdResult::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_metadata = false;
+  bool isset_includeBitset = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->metadata);
+          isset_metadata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->includeBitset);
+          isset_includeBitset = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_metadata)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_includeBitset)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t MetadataPpdResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("MetadataPpdResult");
+
+  xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->metadata);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("includeBitset", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->includeBitset);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(MetadataPpdResult &a, MetadataPpdResult &b) {
+  using ::std::swap;
+  swap(a.metadata, b.metadata);
+  swap(a.includeBitset, b.includeBitset);
+}
+
+MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other609) {
+  metadata = other609.metadata;
+  includeBitset = other609.includeBitset;
+}
+MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other610) {
+  metadata = other610.metadata;
+  includeBitset = other610.includeBitset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const MetadataPpdResult& obj) {
+  using apache::thrift::to_string;
+  out << "MetadataPpdResult(";
+  out << "metadata=" << to_string(obj.metadata);
+  out << ", " << "includeBitset=" << to_string(obj.includeBitset);
+  out << ")";
+  return out;
+}
+
+
+GetFileMetadataByExprResult::~GetFileMetadataByExprResult() throw() {
+}
+
+
+void GetFileMetadataByExprResult::__set_metadata(const std::map<int64_t, MetadataPpdResult> & val) {
+  this->metadata = val;
+}
+
+void GetFileMetadataByExprResult::__set_isSupported(const bool val) {
+  this->isSupported = val;
+}
+
+void GetFileMetadataByExprResult::__set_unknownFileIds(const std::vector<int64_t> & val) {
+  this->unknownFileIds = val;
+}
+
+const char* GetFileMetadataByExprResult::ascii_fingerprint = "2B0C1B8D7599529A5797481BE308375D";
+const uint8_t GetFileMetadataByExprResult::binary_fingerprint[16] = {0x2B,0x0C,0x1B,0x8D,0x75,0x99,0x52,0x9A,0x57,0x97,0x48,0x1B,0xE3,0x08,0x37,0x5D};
+
+uint32_t GetFileMetadataByExprResult::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_metadata = false;
+  bool isset_isSupported = false;
+  bool isset_unknownFileIds = 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_MAP) {
+          {
+            this->metadata.clear();
+            uint32_t _size611;
+            ::apache::thrift::protocol::TType _ktype612;
+            ::apache::thrift::protocol::TType _vtype613;
+            xfer += iprot->readMapBegin(_ktype612, _vtype613, _size611);
+            uint32_t _i615;
+            for (_i615 = 0; _i615 < _size611; ++_i615)
+            {
+              int64_t _key616;
+              xfer += iprot->readI64(_key616);
+              MetadataPpdResult& _val617 = this->metadata[_key616];
+              xfer += _val617.read(iprot);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_metadata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->isSupported);
+          isset_isSupported = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->unknownFileIds.clear();
+            uint32_t _size618;
+            ::apache::thrift::protocol::TType _etype621;
+            xfer += iprot->readListBegin(_etype621, _size618);
+            this->unknownFileIds.resize(_size618);
+            uint32_t _i622;
+            for (_i622 = 0; _i622 < _size618; ++_i622)
+            {
+              xfer += iprot->readI64(this->unknownFileIds[_i622]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_unknownFileIds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_metadata)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_isSupported)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_unknownFileIds)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("GetFileMetadataByExprResult");
+
+  xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->metadata.size()));
+    std::map<int64_t, MetadataPpdResult> ::const_iterator _iter623;
+    for (_iter623 = this->metadata.begin(); _iter623 != this->metadata.end(); ++_iter623)
+    {
+      xfer += oprot->writeI64(_iter623->first);
+      xfer += _iter623->second.write(oprot);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("isSupported", ::apache::thrift::protocol::T_BOOL, 2);
+  xfer += oprot->writeBool(this->isSupported);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("unknownFileIds", ::apache::thrift::protocol::T_LIST, 3);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->unknownFileIds.size()));
+    std::vector<int64_t> ::const_iterator _iter624;
+    for (_iter624 = this->unknownFileIds.begin(); _iter624 != this->unknownFileIds.end(); ++_iter624)
+    {
+      xfer += oprot->writeI64((*_iter624));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) {
+  using ::std::swap;
+  swap(a.metadata, b.metadata);
+  swap(a.isSupported, b.isSupported);
+  swap(a.unknownFileIds, b.unknownFileIds);
+}
+
+GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other625) {
+  metadata = other625.metadata;
+  isSupported = other625.isSupported;
+  unknownFileIds = other625.unknownFileIds;
+}
+GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other626) {
+  metadata = other626.metadata;
+  isSupported = other626.isSupported;
+  unknownFileIds = other626.unknownFileIds;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetFileMetadataByExprResult& obj) {
+  using apache::thrift::to_string;
+  out << "GetFileMetadataByExprResult(";
+  out << "metadata=" << to_string(obj.metadata);
+  out << ", " << "isSupported=" << to_string(obj.isSupported);
+  out << ", " << "unknownFileIds=" << to_string(obj.unknownFileIds);
+  out << ")";
+  return out;
+}
+
+
+GetFileMetadataByExprRequest::~GetFileMetadataByExprRequest() throw() {
+}
+
+
+void GetFileMetadataByExprRequest::__set_fileIds(const std::vector<int64_t> & val) {
+  this->fileIds = val;
+}
+
+void GetFileMetadataByExprRequest::__set_expr(const std::string& val) {
+  this->expr = val;
+}
+
+const char* GetFileMetadataByExprRequest::ascii_fingerprint = "925353917FC0AF87976A2338011F5A31";
+const uint8_t GetFileMetadataByExprRequest::binary_fingerprint[16] = {0x92,0x53,0x53,0x91,0x7F,0xC0,0xAF,0x87,0x97,0x6A,0x23,0x38,0x01,0x1F,0x5A,0x31};
+
+uint32_t GetFileMetadataByExprRequest::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_fileIds = false;
+  bool isset_expr = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->fileIds.clear();
+            uint32_t _size627;
+            ::apache::thrift::protocol::TType _etype630;
+            xfer += iprot->readListBegin(_etype630, _size627);
+            this->fileIds.resize(_size627);
+            uint32_t _i631;
+            for (_i631 = 0; _i631 < _size627; ++_i631)
+            {
+              xfer += iprot->readI64(this->fileIds[_i631]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_fileIds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->expr);
+          isset_expr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_fileIds)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_expr)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("GetFileMetadataByExprRequest");
+
+  xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->fileIds.size()));
+    std::vector<int64_t> ::const_iterator _iter632;
+    for (_iter632 = this->fileIds.begin(); _iter632 != this->fileIds.end(); ++_iter632)
+    {
+      xfer += oprot->writeI64((*_iter632));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("expr", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->expr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) {
+  using ::std::swap;
+  swap(a.fileIds, b.fileIds);
+  swap(a.expr, b.expr);
+}
+
+GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other633) {
+  fileIds = other633.fileIds;
+  expr = other633.expr;
+}
+GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other634) {
+  fileIds = other634.fileIds;
+  expr = other634.expr;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetFileMetadataByExprRequest& obj) {
+  using apache::thrift::to_string;
+  out << "GetFileMetadataByExprRequest(";
+  out << "fileIds=" << to_string(obj.fileIds);
+  out << ", " << "expr=" << to_string(obj.expr);
+  out << ")";
+  return out;
+}
+
+
+GetFileMetadataResult::~GetFileMetadataResult() throw() {
+}
+
+
+void GetFileMetadataResult::__set_metadata(const std::map<int64_t, std::string> & val) {
+  this->metadata = val;
+}
+
+void GetFileMetadataResult::__set_isSupported(const bool val) {
+  this->isSupported = val;
+}
+
+const char* GetFileMetadataResult::ascii_fingerprint = "D18BCBD4BA945E7F6500F5CD95205706";
+const uint8_t GetFileMetadataResult::binary_fingerprint[16] = {0xD1,0x8B,0xCB,0xD4,0xBA,0x94,0x5E,0x7F,0x65,0x00,0xF5,0xCD,0x95,0x20,0x57,0x06};
+
+uint32_t GetFileMetadataResult::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_metadata = false;
+  bool isset_isSupported = 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_MAP) {
+          {
+            this->metadata.clear();
+            uint32_t _size635;
+            ::apache::thrift::protocol::TType _ktype636;
+            ::apache::thrift::protocol::TType _vtype637;
+            xfer += iprot->readMapBegin(_ktype636, _vtype637, _size635);
+            uint32_t _i639;
+            for (_i639 = 0; _i639 < _size635; ++_i639)
+            {
+              int64_t _key640;
+              xfer += iprot->readI64(_key640);
+              std::string& _val641 = this->metadata[_key640];
+              xfer += iprot->readBinary(_val641);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_metadata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->isSupported);
+          isset_isSupported = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_metadata)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_isSupported)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("GetFileMetadataResult");
+
+  xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->metadata.size()));
+    std::map<int64_t, std::string> ::const_iterator _iter642;
+    for (_iter642 = this->metadata.begin(); _iter642 != this->metadata.end(); ++_iter642)
+    {
+      xfer += oprot->writeI64(_iter642->first);
+      xfer += oprot->writeBinary(_iter642->second);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("isSupported", ::apache::thrift::protocol::T_BOOL, 2);
+  xfer += oprot->writeBool(this->isSupported);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) {
+  using ::std::swap;
+  swap(a.metadata, b.metadata);
+  swap(a.isSupported, b.isSupported);
+}
+
+GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other643) {
+  metadata = other643.metadata;
+  isSupported = other643.isSupported;
+}
+GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other644) {
+  metadata = other644.metadata;
+  isSupported = other644.isSupported;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetFileMetadataResult& obj) {
+  using apache::thrift::to_string;
+  out << "GetFileMetadataResult(";
+  out << "metadata=" << to_string(obj.metadata);
+  out << ", " << "isSupported=" << to_string(obj.isSupported);
+  out << ")";
+  return out;
+}
+
+
+GetFileMetadataRequest::~GetFileMetadataRequest() throw() {
+}
+
+
+void GetFileMetadataRequest::__set_fileIds(const std::vector<int64_t> & val) {
+  this->fileIds = val;
+}
+
+const char* GetFileMetadataRequest::ascii_fingerprint = "E49D7D1A9013CC81CD0F69D631EF82E4";
+const uint8_t GetFileMetadataRequest::binary_fingerprint[16] = {0xE4,0x9D,0x7D,0x1A,0x90,0x13,0xCC,0x81,0xCD,0x0F,0x69,0xD6,0x31,0xEF,0x82,0xE4};
+
+uint32_t GetFileMetadataRequest::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_fileIds = 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->fileIds.clear();
+            uint32_t _size645;
+            ::apache::thrift::protocol::TType _etype648;
+            xfer += iprot->readListBegin(_etype648, _size645);
+            this->fileIds.resize(_size645);
+            uint32_t _i649;
+            for (_i649 = 0; _i649 < _size645; ++_i649)
+            {
+              xfer += iprot->readI64(this->fileIds[_i649]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_fileIds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_fileIds)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("GetFileMetadataRequest");
+
+  xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->fileIds.size()));
+    std::vector<int64_t> ::const_iterator _iter650;
+    for (_iter650 = this->fileIds.begin(); _iter650 != this->fileIds.end(); ++_iter650)
+    {
+      xfer += oprot->writeI64((*_iter650));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) {
+  using ::std::swap;
+  swap(a.fileIds, b.fileIds);
+}
+
+GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other651) {
+  fileIds = other651.fileIds;
+}
+GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other652) {
+  fileIds = other652.fileIds;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetFileMetadataRequest& obj) {
+  using apache::thrift::to_string;
+  out << "GetFileMetadataRequest(";
+  out << "fileIds=" << to_string(obj.fileIds);
+  out << ")";
+  return out;
+}
+
+
+PutFileMetadataResult::~PutFileMetadataResult() throw() {
+}
+
+
+const char* PutFileMetadataResult::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t PutFileMetadataResult::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t PutFileMetadataResult::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;
+    }
+    xfer += iprot->skip(ftype);
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t PutFileMetadataResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("PutFileMetadataResult");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other653) {
+  (void) other653;
+}
+PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other654) {
+  (void) other654;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const PutFileMetadataResult& obj) {
+  using apache::thrift::to_string;
+  (void) obj;
+  out << "PutFileMetadataResult(";
+  out << ")";
+  return out;
+}
+
+
+PutFileMetadataRequest::~PutFileMetadataRequest() throw() {
+}
+
+
+void PutFileMetadataRequest::__set_fileIds(const std::vector<int64_t> & val) {
+  this->fileIds = val;
+}
+
+void PutFileMetadataRequest::__set_metadata(const std::vector<std::string> & val) {
+  this->metadata = val;
+}
+
+const char* PutFileMetadataRequest::ascii_fingerprint = "D64A208A8BCFCE146F4E2CB2176A807C";
+const uint8_t PutFileMetadataRequest::binary_fingerprint[16] = {0xD6,0x4A,0x20,0x8A,0x8B,0xCF,0xCE,0x14,0x6F,0x4E,0x2C,0xB2,0x17,0x6A,0x80,0x7C};
+
+uint32_t PutFileMetadataRequest::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_fileIds = false;
+  bool isset_metadata = 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->fileIds.clear();
+            uint32_t _size655;
+            ::apache::thrift::protocol::TType _etype658;
+            xfer += iprot->readListBegin(_etype658, _size655);
+            this->fileIds.resize(_size655);
+            uint32_t _i659;
+            for (_i659 = 0; _i659 < _size655; ++_i659)
+            {
+              xfer += iprot->readI64(this->fileIds[_i659]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_fileIds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->metadata.clear();
+            uint32_t _size660;
+            ::apache::thrift::protocol::TType _etype663;
+            xfer += iprot->readListBegin(_etype663, _size660);
+            this->metadata.resize(_size660);
+            uint32_t _i664;
+            for (_i664 = 0; _i664 < _size660; ++_i664)
+            {
+              xfer += iprot->readBinary(this->metadata[_i664]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_metadata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_fileIds)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_metadata)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("PutFileMetadataRequest");
+
+  xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->fileIds.size()));
+    std::vector<int64_t> ::const_iterator _iter665;
+    for (_iter665 = this->fileIds.begin(); _iter665 != this->fileIds.end(); ++_iter665)
+    {
+      xfer += oprot->writeI64((*_iter665));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->metadata.size()));
+    std::vector<std::string> ::const_iterator _iter666;
+    for (_iter666 = this->metadata.begin(); _iter666 != this->metadata.end(); ++_iter666)
+    {
+      xfer += oprot->writeBinary((*_iter666));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) {
+  using ::std::swap;
+  swap(a.fileIds, b.fileIds);
+  swap(a.metadata, b.metadata);
+}
+
+PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other667) {
+  fileIds = other667.fileIds;
+  metadata = other667.metadata;
+}
+PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other668) {
+  fileIds = other668.fileIds;
+  metadata = other668.metadata;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const PutFileMetadataRequest& obj) {
+  using apache::thrift::to_string;
+  out << "PutFileMetadataRequest(";
+  out << "fileIds=" << to_string(obj.fileIds);
+  out << ", " << "metadata=" << to_string(obj.metadata);
+  out << ")";
+  return out;
+}
+
+
+ClearFileMetadataResult::~ClearFileMetadataResult() throw() {
+}
+
+
+const char* ClearFileMetadataResult::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t ClearFileMetadataResult::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t ClearFileMetadataResult::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;
+    }
+    xfer += iprot->skip(ftype);
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t ClearFileMetadataResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ClearFileMetadataResult");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other669) {
+  (void) other669;
+}
+ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other670) {
+  (void) other670;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ClearFileMetadataResult& obj) {
+  using apache::thrift::to_string;
+  (void) obj;
+  out << "ClearFileMetadataResult(";
+  out << ")";
+  return out;
+}
+
+
+ClearFileMetadataRequest::~ClearFileMetadataRequest() throw() {
+}
+
+
+void ClearFileMetadataRequest::__set_fileIds(const std::vector<int64_t> & val) {
+  this->fileIds = val;
+}
+
+const char* ClearFileMetadataRequest::ascii_fingerprint = "E49D7D1A9013CC81CD0F69D631EF82E4";
+const uint8_t ClearFileMetadataRequest::binary_fingerprint[16] = {0xE4,0x9D,0x7D,0x1A,0x90,0x13,0xCC,0x81,0xCD,0x0F,0x69,0xD6,0x31,0xEF,0x82,0xE4};
+
+uint32_t ClearFileMetadataRequest::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_fileIds = 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->fileIds.clear();
+            uint32_t _size671;
+            ::apache::thrift::protocol::TType _etype674;
+            xfer += iprot->readListBegin(_etype674, _size671);
+            this->fileIds.resize(_size671);
+            uint32_t _i675;
+            for (_i675 = 0; _i675 < _size671; ++_i675)
+            {
+              xfer += iprot->readI64(this->fileIds[_i675]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_fileIds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_fileIds)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ClearFileMetadataRequest");
+
+  xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->fileIds.size()));
+    std::vector<int64_t> ::const_iterator _iter676;
+    for (_iter676 = this->fileIds.begin(); _iter676 != this->fileIds.end(); ++_iter676)
+    {
+      xfer += oprot->writeI64((*_iter676));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) {
+  using ::std::swap;
+  swap(a.fileIds, b.fileIds);
+}
+
+ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other677) {
+  fileIds = other677.fileIds;
+}
+ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other678) {
+  fileIds = other678.fileIds;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ClearFileMetadataRequest& obj) {
+  using apache::thrift::to_string;
+  out << "ClearFileMetadataRequest(";
+  out << "fileIds=" << to_string(obj.fileIds);
+  out << ")";
+  return out;
+}
+
+
 GetAllFunctionsResponse::~GetAllFunctionsResponse() throw() {
 }
 
@@ -14409,14 +15479,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->functions.clear();
-            uint32_t _size609;
-            ::apache::thrift::protocol::TType _etype612;
-            xfer += iprot->readListBegin(_etype612, _size609);
-            this->functions.resize(_size609);
-            uint32_t _i613;
-            for (_i613 = 0; _i613 < _size609; ++_i613)
+            uint32_t _size679;
+            ::apache::thrift::protocol::TType _etype682;
+            xfer += iprot->readListBegin(_etype682, _size679);
+            this->functions.resize(_size679);
+            uint32_t _i683;
+            for (_i683 = 0; _i683 < _size679; ++_i683)
             {
-              xfer += this->functions[_i613].read(iprot);
+              xfer += this->functions[_i683].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -14446,10 +15516,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o
     xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->functions.size()));
-      std::vector<Function> ::const_iterator _iter614;
-      for (_iter614 = this->functions.begin(); _iter614 != this->functions.end(); ++_iter614)
+      std::vector<Function> ::const_iterator _iter684;
+      for (_iter684 = this->functions.begin(); _iter684 != this->functions.end(); ++_iter684)
       {
-        xfer += (*_iter614).write(oprot);
+        xfer += (*_iter684).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -14467,13 +15537,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) {
   swap(a.__isset, b.__isset);
 }
 
-GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other615) {
-  functions = other615.functions;
-  __isset = other615.__isset;
+GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other685) {
+  functions = other685.functions;
+  __isset = other685.__isset;
 }
-GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other616) {
-  functions = other616.functions;
-  __isset = other616.__isset;
+GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other686) {
+  functions = other686.functions;
+  __isset = other686.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const GetAllFunctionsResponse& obj) {
@@ -14557,13 +15627,13 @@ void swap(MetaException &a, MetaException &b) {
   swap(a.__isset, b.__isset);
 }
 
-MetaException::MetaException(const MetaException& other617) : TException() {
-  message = other617.message;
-  __isset = other617.__isset;
+MetaException::MetaException(const MetaException& other687) : TException() {
+  message = other687.message;
+  __isset = other687.__isset;
 }
-MetaException& MetaException::operator=(const MetaException& other618) {
-  message = other618.message;
-  __isset = other618.__isset;
+MetaException& MetaException::operator=(const MetaException& other688) {
+  message = other688.message;
+  __isset = other688.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const MetaException& obj) {
@@ -14647,13 +15717,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownTableException::UnknownTableException(const UnknownTableException& other619) : TException() {
-  message = other619.message;
-  __isset = other619.__isset;
+UnknownTableException::UnknownTableException(const UnknownTableException& other689) : TException() {
+  message = other689.message;
+  __isset = other689.__isset;
 }
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other620) {
-  message = other620.message;
-  __isset = other620.__isset;
+UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other690) {
+  message = other690.message;
+  __isset = other690.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const UnknownTableException& obj) {
@@ -14737,13 +15807,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownDBException::UnknownDBException(const UnknownDBException& other621) : TException() {
-  message = other621.message;
-  __isset = other621.__isset;
+UnknownDBException::UnknownDBException(const UnknownDBException& other691) : TException() {
+  message = other691.message;
+  __isset = other691.__isset;
 }
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other622) {
-  message = other622.message;
-  __isset = other622.__isset;
+UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other692) {
+  message = other692.message;
+  __isset = other692.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const UnknownDBException& obj) {
@@ -14827,13 +15897,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) {
   swap(a.__isset, b.__isset);
 }
 
-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other623) : TException() {
-  message = other623.message;
-  __isset = other623.__isset;
+AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other693) : TException() {
+  message = other693.message;
+  __isset = other693.__isset;
 }
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other624) {
-  message = other624.message;
-  __isset = other624.__isset;
+AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other694) {
+  message = other694.message;
+  __isset = other694.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const AlreadyExistsException& obj) {
@@ -14917,13 +15987,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other625) : TException() {
-  message = other625.message;
-  __isset = other625.__isset;
+InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other695) : TException() {
+  message = other695.message;
+  __isset = other695.__isset;
 }
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other626) {
-  message = other626.message;
-  __isset = other626.__isset;
+InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other696) {
+  message = other696.message;
+  __isset = other696.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const InvalidPartitionException& obj) {
@@ -15007,13 +16077,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other627) : TException() {
-  message = other627.message;
-  __isset = other627.__isset;
+UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other697) : TException() {
+  message = other697.message;
+  __isset = other697.__isset;
 }
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other628) {
-  message = other628.message;
-  __isset = other628.__isset;
+UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other698) {
+  message = other698.message;
+  __isset = other698.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const UnknownPartitionException& obj) {
@@ -15097,13 +16167,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other629) : TException() {
-  message = other629.message;
-  __isset = other629.__isset;
+InvalidObjectException::InvalidObjectException(const InvalidObjectException& other699) : TException() {
+  message = other699.message;
+  __isset = other699.__isset;
 }
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other630) {
-  message = other630.message;
-  __isset = other630.__isset;
+InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other700) {
+  message = other700.message;
+  __isset = other700.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const InvalidObjectException& obj) {
@@ -15187,13 +16257,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other631) : TException() {
-  message = other631.message;
-  __isset = other631.__isset;
+NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other701) : TException() {
+  message = other701.message;
+  __isset = other701.__isset;
 }
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other632) {
-  message = other632.message;
-  __isset = other632.__isset;
+NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other702) {
+  message = other702.message;
+  __isset = other702.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const NoSuchObjectException& obj) {
@@ -15277,13 +16347,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) {
   swap(a.__isset, b.__isset);
 }
 
-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other633) : TException() {
-  message = other633.message;
-  __isset = other633.__isset;
+IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other703) : TException() {
+  message = other703.message;
+  __isset = other703.__isset;
 }
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other634) {
-  message = other634.message;
-  __isset = other634.__isset;
+IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other704) {
+  message = other704.message;
+  __isset = other704.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const IndexAlreadyExistsException& obj) {
@@ -15367,13 +16437,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other635) : TException() {
-  message = other635.message;
-  __isset = other635.__isset;
+InvalidOperationException::InvalidOperationException(const InvalidOperationException& other705) : TException() {
+  message = other705.message;
+  __isset = other705.__isset;
 }
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other636) {
-  message = other636.message;
-  __isset = other636.__isset;
+InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other706) {
+  message = other706.message;
+  __isset = other706.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const InvalidOperationException& obj) {
@@ -15457,13 +16527,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) {
   swap(a.__isset, b.__isset);
 }
 
-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other637) : TException() {
-  message = other637.message;
-  __isset = other637.__isset;
+ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other707) : TException() {
+  message = other707.message;
+  __isset = other707.__isset;
 }
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other638) {
-  message = other638.message;
-  __isset = other638.__isset;
+ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other708) {
+  message = other708.message;
+  __isset = other708.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const ConfigValSecurityException& obj) {
@@ -15547,13 +16617,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidInputException::InvalidInputException(const InvalidInputException& other639) : TException() {
-  message = other639.message;
-  __isset = other639.__isset;
+InvalidInputException::InvalidInputException(const InvalidInputException& other709) : TException() {
+  message = other709.message;
+  __isset = other709.__isset;
 }
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other640) {
-  message = other640.message;
-  __isset = other640.__isset;
+InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other710) {
+  message = other710.message;
+  __isset = other710.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const InvalidInputException& obj) {
@@ -15637,13 +16707,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other641) : TException() {
-  message = other641.message;
-  __isset = other641.__isset;
+NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other711) : TException() {
+  message = other711.message;
+  __isset = other711.__isset;
 }
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other642) {
-  message = other642.message;
-  __isset = other642.__isset;
+NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other712) {
+  message = other712.message;
+  __isset = other712.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const NoSuchTxnException& obj) {
@@ -15727,13 +16797,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other643) : TException() {
-  message = other643.message;
-  __isset = other643.__isset;
+TxnAbortedException::TxnAbortedException(const TxnAbortedException& other713) : TException() {
+  message = other713.message;
+  __isset = other713.__isset;
 }
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other644) {
-  message = other644.message;
-  __isset = other644.__isset;
+TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other714) {
+  message = other714.message;
+  __isset = other714.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const TxnAbortedException& obj) {
@@ -15817,13 +16887,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnOpenException::TxnOpenException(const TxnOpenException& other645) : TException() {
-  message = other645.message;
-  __isset = other645.__isset;
+TxnOpenException::TxnOpenException(const TxnOpenException& other715) : TException() {
+  message = other715.message;
+  __isset = other715.__isset;
 }
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other646) {
-  message = other646.message;
-  __isset = other646.__isset;
+TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other716) {
+  message = other716.message;
+  __isset = other716.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const TxnOpenException& obj) {
@@ -15907,13 +16977,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other647) : TException() {
-  message = other647.message;
-  __isset = other647.__isset;
+NoSuchLockException::NoSuchLockException(const NoSuchLockException& other717) : TException() {
+  message = other717.message;
+  __isset = other717.__isset;
 }
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other648) {
-  message = other648.message;
-  __isset = other648.__isset;
+NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other718) {
+  message = other718.message;
+  __isset = other718.__isset;
   return *this;
 }
 std::ostream& operator<<(std::ostream& out, const NoSuchLockException& obj) {


Mime
View raw message