You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2015/09/22 23:32:15 UTC
[34/52] [abbrv] hive git commit: HIVE-11552 : implement basic methods
for getting/putting file metadata (Sergey Shelukhin, reviewed by Alan Gates)
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) {