hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gunt...@apache.org
Subject svn commit: r1571600 [6/46] - in /hive/branches/tez: ./ ant/src/org/apache/hadoop/hive/ant/ common/src/java/org/apache/hadoop/hive/common/ common/src/java/org/apache/hadoop/hive/common/type/ common/src/java/org/apache/hadoop/hive/conf/ common/src/java/...
Date Tue, 25 Feb 2014 07:59:20 GMT
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;



Mime
View raw message