Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1571600&r1=1571599&r2=1571600&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Tue Feb 25 07:58:52 2014 @@ -89,6 +89,11 @@ class ThriftHiveMetastoreIf : virtual pu virtual void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) = 0; virtual bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) = 0; virtual bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) = 0; + virtual void create_function(const Function& func) = 0; + virtual void drop_function(const std::string& dbName, const std::string& funcName) = 0; + virtual void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) = 0; + virtual void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern) = 0; + virtual void get_function(Function& _return, const std::string& dbName, const std::string& funcName) = 0; virtual bool create_role(const Role& role) = 0; virtual bool drop_role(const std::string& role_name) = 0; virtual void get_role_names(std::vector<std::string> & _return) = 0; @@ -365,6 +370,21 @@ class ThriftHiveMetastoreNull : virtual bool _return = false; return _return; } + void create_function(const Function& /* func */) { + return; + } + void drop_function(const std::string& /* dbName */, const std::string& /* funcName */) { + return; + } + void alter_function(const std::string& /* dbName */, const std::string& /* funcName */, const Function& /* newFunc */) { + return; + } + void get_functions(std::vector<std::string> & /* _return */, const std::string& /* dbName */, const std::string& /* pattern */) { + return; + } + void get_function(Function& /* _return */, const std::string& /* dbName */, const std::string& /* funcName */) { + return; + } bool create_role(const Role& /* role */) { bool _return = false; return _return; @@ -11013,6 +11033,671 @@ class ThriftHiveMetastore_delete_table_c }; +typedef struct _ThriftHiveMetastore_create_function_args__isset { + _ThriftHiveMetastore_create_function_args__isset() : func(false) {} + bool func; +} _ThriftHiveMetastore_create_function_args__isset; + +class ThriftHiveMetastore_create_function_args { + public: + + ThriftHiveMetastore_create_function_args() { + } + + virtual ~ThriftHiveMetastore_create_function_args() throw() {} + + Function func; + + _ThriftHiveMetastore_create_function_args__isset __isset; + + void __set_func(const Function& val) { + func = val; + } + + bool operator == (const ThriftHiveMetastore_create_function_args & rhs) const + { + if (!(func == rhs.func)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_create_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_function_pargs() throw() {} + + const Function* func; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_function_result__isset { + _ThriftHiveMetastore_create_function_result__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1; + bool o2; + bool o3; + bool o4; +} _ThriftHiveMetastore_create_function_result__isset; + +class ThriftHiveMetastore_create_function_result { + public: + + ThriftHiveMetastore_create_function_result() { + } + + virtual ~ThriftHiveMetastore_create_function_result() throw() {} + + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_function_result__isset __isset; + + void __set_o1(const AlreadyExistsException& val) { + o1 = val; + } + + void __set_o2(const InvalidObjectException& val) { + o2 = val; + } + + void __set_o3(const MetaException& val) { + o3 = val; + } + + void __set_o4(const NoSuchObjectException& val) { + o4 = val; + } + + bool operator == (const ThriftHiveMetastore_create_function_result & rhs) const + { + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + if (!(o3 == rhs.o3)) + return false; + if (!(o4 == rhs.o4)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_create_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_function_presult__isset { + _ThriftHiveMetastore_create_function_presult__isset() : o1(false), o2(false), o3(false), o4(false) {} + bool o1; + bool o2; + bool o3; + bool o4; +} _ThriftHiveMetastore_create_function_presult__isset; + +class ThriftHiveMetastore_create_function_presult { + public: + + + virtual ~ThriftHiveMetastore_create_function_presult() throw() {} + + AlreadyExistsException o1; + InvalidObjectException o2; + MetaException o3; + NoSuchObjectException o4; + + _ThriftHiveMetastore_create_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_function_args__isset { + _ThriftHiveMetastore_drop_function_args__isset() : dbName(false), funcName(false) {} + bool dbName; + bool funcName; +} _ThriftHiveMetastore_drop_function_args__isset; + +class ThriftHiveMetastore_drop_function_args { + public: + + ThriftHiveMetastore_drop_function_args() : dbName(), funcName() { + } + + virtual ~ThriftHiveMetastore_drop_function_args() throw() {} + + std::string dbName; + std::string funcName; + + _ThriftHiveMetastore_drop_function_args__isset __isset; + + void __set_dbName(const std::string& val) { + dbName = val; + } + + void __set_funcName(const std::string& val) { + funcName = val; + } + + bool operator == (const ThriftHiveMetastore_drop_function_args & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(funcName == rhs.funcName)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_function_pargs() throw() {} + + const std::string* dbName; + const std::string* funcName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_function_result__isset { + _ThriftHiveMetastore_drop_function_result__isset() : o1(false), o3(false) {} + bool o1; + bool o3; +} _ThriftHiveMetastore_drop_function_result__isset; + +class ThriftHiveMetastore_drop_function_result { + public: + + ThriftHiveMetastore_drop_function_result() { + } + + virtual ~ThriftHiveMetastore_drop_function_result() throw() {} + + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_function_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val) { + o1 = val; + } + + void __set_o3(const MetaException& val) { + o3 = val; + } + + bool operator == (const ThriftHiveMetastore_drop_function_result & rhs) const + { + if (!(o1 == rhs.o1)) + return false; + if (!(o3 == rhs.o3)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_function_presult__isset { + _ThriftHiveMetastore_drop_function_presult__isset() : o1(false), o3(false) {} + bool o1; + bool o3; +} _ThriftHiveMetastore_drop_function_presult__isset; + +class ThriftHiveMetastore_drop_function_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_function_presult() throw() {} + + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_function_args__isset { + _ThriftHiveMetastore_alter_function_args__isset() : dbName(false), funcName(false), newFunc(false) {} + bool dbName; + bool funcName; + bool newFunc; +} _ThriftHiveMetastore_alter_function_args__isset; + +class ThriftHiveMetastore_alter_function_args { + public: + + ThriftHiveMetastore_alter_function_args() : dbName(), funcName() { + } + + virtual ~ThriftHiveMetastore_alter_function_args() throw() {} + + std::string dbName; + std::string funcName; + Function newFunc; + + _ThriftHiveMetastore_alter_function_args__isset __isset; + + void __set_dbName(const std::string& val) { + dbName = val; + } + + void __set_funcName(const std::string& val) { + funcName = val; + } + + void __set_newFunc(const Function& val) { + newFunc = val; + } + + bool operator == (const ThriftHiveMetastore_alter_function_args & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(funcName == rhs.funcName)) + return false; + if (!(newFunc == rhs.newFunc)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_alter_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_function_pargs() throw() {} + + const std::string* dbName; + const std::string* funcName; + const Function* newFunc; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_function_result__isset { + _ThriftHiveMetastore_alter_function_result__isset() : o1(false), o2(false) {} + bool o1; + bool o2; +} _ThriftHiveMetastore_alter_function_result__isset; + +class ThriftHiveMetastore_alter_function_result { + public: + + ThriftHiveMetastore_alter_function_result() { + } + + virtual ~ThriftHiveMetastore_alter_function_result() throw() {} + + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_function_result__isset __isset; + + void __set_o1(const InvalidOperationException& val) { + o1 = val; + } + + void __set_o2(const MetaException& val) { + o2 = val; + } + + bool operator == (const ThriftHiveMetastore_alter_function_result & rhs) const + { + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_alter_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_function_presult__isset { + _ThriftHiveMetastore_alter_function_presult__isset() : o1(false), o2(false) {} + bool o1; + bool o2; +} _ThriftHiveMetastore_alter_function_presult__isset; + +class ThriftHiveMetastore_alter_function_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_function_presult() throw() {} + + InvalidOperationException o1; + MetaException o2; + + _ThriftHiveMetastore_alter_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_functions_args__isset { + _ThriftHiveMetastore_get_functions_args__isset() : dbName(false), pattern(false) {} + bool dbName; + bool pattern; +} _ThriftHiveMetastore_get_functions_args__isset; + +class ThriftHiveMetastore_get_functions_args { + public: + + ThriftHiveMetastore_get_functions_args() : dbName(), pattern() { + } + + virtual ~ThriftHiveMetastore_get_functions_args() throw() {} + + std::string dbName; + std::string pattern; + + _ThriftHiveMetastore_get_functions_args__isset __isset; + + void __set_dbName(const std::string& val) { + dbName = val; + } + + void __set_pattern(const std::string& val) { + pattern = val; + } + + bool operator == (const ThriftHiveMetastore_get_functions_args & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(pattern == rhs.pattern)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_functions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_functions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_functions_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_functions_pargs() throw() {} + + const std::string* dbName; + const std::string* pattern; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_functions_result__isset { + _ThriftHiveMetastore_get_functions_result__isset() : success(false), o1(false) {} + bool success; + bool o1; +} _ThriftHiveMetastore_get_functions_result__isset; + +class ThriftHiveMetastore_get_functions_result { + public: + + ThriftHiveMetastore_get_functions_result() { + } + + virtual ~ThriftHiveMetastore_get_functions_result() throw() {} + + std::vector<std::string> success; + MetaException o1; + + _ThriftHiveMetastore_get_functions_result__isset __isset; + + void __set_success(const std::vector<std::string> & val) { + success = val; + } + + void __set_o1(const MetaException& val) { + o1 = val; + } + + bool operator == (const ThriftHiveMetastore_get_functions_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_functions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_functions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_functions_presult__isset { + _ThriftHiveMetastore_get_functions_presult__isset() : success(false), o1(false) {} + bool success; + bool o1; +} _ThriftHiveMetastore_get_functions_presult__isset; + +class ThriftHiveMetastore_get_functions_presult { + public: + + + virtual ~ThriftHiveMetastore_get_functions_presult() throw() {} + + std::vector<std::string> * success; + MetaException o1; + + _ThriftHiveMetastore_get_functions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_function_args__isset { + _ThriftHiveMetastore_get_function_args__isset() : dbName(false), funcName(false) {} + bool dbName; + bool funcName; +} _ThriftHiveMetastore_get_function_args__isset; + +class ThriftHiveMetastore_get_function_args { + public: + + ThriftHiveMetastore_get_function_args() : dbName(), funcName() { + } + + virtual ~ThriftHiveMetastore_get_function_args() throw() {} + + std::string dbName; + std::string funcName; + + _ThriftHiveMetastore_get_function_args__isset __isset; + + void __set_dbName(const std::string& val) { + dbName = val; + } + + void __set_funcName(const std::string& val) { + funcName = val; + } + + bool operator == (const ThriftHiveMetastore_get_function_args & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(funcName == rhs.funcName)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_function_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_function_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_function_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_function_pargs() throw() {} + + const std::string* dbName; + const std::string* funcName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_function_result__isset { + _ThriftHiveMetastore_get_function_result__isset() : success(false), o1(false), o2(false) {} + bool success; + bool o1; + bool o2; +} _ThriftHiveMetastore_get_function_result__isset; + +class ThriftHiveMetastore_get_function_result { + public: + + ThriftHiveMetastore_get_function_result() { + } + + virtual ~ThriftHiveMetastore_get_function_result() throw() {} + + Function success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_function_result__isset __isset; + + void __set_success(const Function& val) { + success = val; + } + + void __set_o1(const MetaException& val) { + o1 = val; + } + + void __set_o2(const NoSuchObjectException& val) { + o2 = val; + } + + bool operator == (const ThriftHiveMetastore_get_function_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_function_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_function_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_function_presult__isset { + _ThriftHiveMetastore_get_function_presult__isset() : success(false), o1(false), o2(false) {} + bool success; + bool o1; + bool o2; +} _ThriftHiveMetastore_get_function_presult__isset; + +class ThriftHiveMetastore_get_function_presult { + public: + + + virtual ~ThriftHiveMetastore_get_function_presult() throw() {} + + Function* success; + MetaException o1; + NoSuchObjectException o2; + + _ThriftHiveMetastore_get_function_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_create_role_args__isset { _ThriftHiveMetastore_create_role_args__isset() : role(false) {} bool role; @@ -12998,6 +13683,21 @@ class ThriftHiveMetastoreClient : virtua bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name); void send_delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name); bool recv_delete_table_column_statistics(); + void create_function(const Function& func); + void send_create_function(const Function& func); + void recv_create_function(); + void drop_function(const std::string& dbName, const std::string& funcName); + void send_drop_function(const std::string& dbName, const std::string& funcName); + void recv_drop_function(); + void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc); + void send_alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc); + void recv_alter_function(); + void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern); + void send_get_functions(const std::string& dbName, const std::string& pattern); + void recv_get_functions(std::vector<std::string> & _return); + void get_function(Function& _return, const std::string& dbName, const std::string& funcName); + void send_get_function(const std::string& dbName, const std::string& funcName); + void recv_get_function(Function& _return); bool create_role(const Role& role); void send_create_role(const Role& role); bool recv_create_role(); @@ -13123,6 +13823,11 @@ class ThriftHiveMetastoreProcessor : pub void process_get_partitions_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_delete_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_delete_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_functions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_create_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_role_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -13214,6 +13919,11 @@ class ThriftHiveMetastoreProcessor : pub processMap_["get_partitions_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_statistics_req; processMap_["delete_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_partition_column_statistics; processMap_["delete_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_table_column_statistics; + processMap_["create_function"] = &ThriftHiveMetastoreProcessor::process_create_function; + processMap_["drop_function"] = &ThriftHiveMetastoreProcessor::process_drop_function; + processMap_["alter_function"] = &ThriftHiveMetastoreProcessor::process_alter_function; + processMap_["get_functions"] = &ThriftHiveMetastoreProcessor::process_get_functions; + processMap_["get_function"] = &ThriftHiveMetastoreProcessor::process_get_function; processMap_["create_role"] = &ThriftHiveMetastoreProcessor::process_create_role; processMap_["drop_role"] = &ThriftHiveMetastoreProcessor::process_drop_role; processMap_["get_role_names"] = &ThriftHiveMetastoreProcessor::process_get_role_names; @@ -13962,6 +14672,53 @@ class ThriftHiveMetastoreMultiface : vir return ifaces_[i]->delete_table_column_statistics(db_name, tbl_name, col_name); } + void create_function(const Function& func) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_function(func); + } + ifaces_[i]->create_function(func); + } + + void drop_function(const std::string& dbName, const std::string& funcName) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_function(dbName, funcName); + } + ifaces_[i]->drop_function(dbName, funcName); + } + + void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_function(dbName, funcName, newFunc); + } + ifaces_[i]->alter_function(dbName, funcName, newFunc); + } + + void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_functions(_return, dbName, pattern); + } + ifaces_[i]->get_functions(_return, dbName, pattern); + return; + } + + void get_function(Function& _return, const std::string& dbName, const std::string& funcName) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_function(_return, dbName, funcName); + } + ifaces_[i]->get_function(_return, dbName, funcName); + return; + } + bool create_role(const Role& role) { size_t sz = ifaces_.size(); size_t i = 0;
Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1571600&r1=1571599&r2=1571600&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Tue Feb 25 07:58:52 2014 @@ -387,6 +387,31 @@ class ThriftHiveMetastoreHandler : virtu printf("delete_table_column_statistics\n"); } + void create_function(const Function& func) { + // Your implementation goes here + printf("create_function\n"); + } + + void drop_function(const std::string& dbName, const std::string& funcName) { + // Your implementation goes here + printf("drop_function\n"); + } + + void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) { + // Your implementation goes here + printf("alter_function\n"); + } + + void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern) { + // Your implementation goes here + printf("get_functions\n"); + } + + void get_function(Function& _return, const std::string& dbName, const std::string& funcName) { + // Your implementation goes here + printf("get_function\n"); + } + bool create_role(const Role& role) { // Your implementation goes here printf("create_role\n"); Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp?rev=1571600&r1=1571599&r2=1571600&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp Tue Feb 25 07:58:52 2014 @@ -23,6 +23,8 @@ hive_metastoreConstants::hive_metastoreC ORIGINAL_LOCATION = "original_location"; + IS_IMMUTABLE = "immutable"; + META_TABLE_COLUMNS = "columns"; META_TABLE_COLUMN_TYPES = "columns.types"; Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h?rev=1571600&r1=1571599&r2=1571600&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h Tue Feb 25 07:58:52 2014 @@ -21,6 +21,7 @@ class hive_metastoreConstants { std::string HIVE_FILTER_FIELD_LAST_ACCESS; std::string IS_ARCHIVED; std::string ORIGINAL_LOCATION; + std::string IS_IMMUTABLE; std::string META_TABLE_COLUMNS; std::string META_TABLE_COLUMN_TYPES; std::string BUCKET_FIELD_NAME;
