hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From na...@apache.org
Subject svn commit: r1057999 [10/22] - in /hive/trunk: ./ common/src/java/org/apache/hadoop/hive/conf/ conf/ metastore/if/ metastore/src/gen/thrift/gen-cpp/ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ metastore/src/gen/thrift/ge...
Date Wed, 12 Jan 2011 06:58:10 GMT
Modified: hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py?rev=1057999&r1=1057998&r2=1057999&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py Wed Jan 12 06:58:04 2011
@@ -206,6 +206,17 @@ class Iface(fb303.FacebookService.Iface)
     """
     pass
 
+  def get_partition_with_auth(self, db_name, tbl_name, part_vals, user_name, group_names):
+    """
+    Parameters:
+     - db_name
+     - tbl_name
+     - part_vals
+     - user_name
+     - group_names
+    """
+    pass
+
   def get_partition_by_name(self, db_name, tbl_name, part_name):
     """
     Parameters:
@@ -224,6 +235,17 @@ class Iface(fb303.FacebookService.Iface)
     """
     pass
 
+  def get_partitions_with_auth(self, db_name, tbl_name, max_parts, user_name, group_names):
+    """
+    Parameters:
+     - db_name
+     - tbl_name
+     - max_parts
+     - user_name
+     - group_names
+    """
+    pass
+
   def get_partition_names(self, db_name, tbl_name, max_parts):
     """
     Parameters:
@@ -243,6 +265,18 @@ class Iface(fb303.FacebookService.Iface)
     """
     pass
 
+  def get_partitions_ps_with_auth(self, db_name, tbl_name, part_vals, max_parts, user_name, group_names):
+    """
+    Parameters:
+     - db_name
+     - tbl_name
+     - part_vals
+     - max_parts
+     - user_name
+     - group_names
+    """
+    pass
+
   def get_partition_names_ps(self, db_name, tbl_name, part_vals, max_parts):
     """
     Parameters:
@@ -349,6 +383,81 @@ class Iface(fb303.FacebookService.Iface)
     """
     pass
 
+  def create_role(self, role):
+    """
+    Parameters:
+     - role
+    """
+    pass
+
+  def drop_role(self, role_name):
+    """
+    Parameters:
+     - role_name
+    """
+    pass
+
+  def grant_role(self, role_name, principal_name, principal_type, grantor, grantorType, grant_option):
+    """
+    Parameters:
+     - role_name
+     - principal_name
+     - principal_type
+     - grantor
+     - grantorType
+     - grant_option
+    """
+    pass
+
+  def revoke_role(self, role_name, principal_name, principal_type):
+    """
+    Parameters:
+     - role_name
+     - principal_name
+     - principal_type
+    """
+    pass
+
+  def list_roles(self, principal_name, principal_type):
+    """
+    Parameters:
+     - principal_name
+     - principal_type
+    """
+    pass
+
+  def get_privilege_set(self, hiveObject, user_name, group_names):
+    """
+    Parameters:
+     - hiveObject
+     - user_name
+     - group_names
+    """
+    pass
+
+  def list_privileges(self, principal_name, principal_type, hiveObject):
+    """
+    Parameters:
+     - principal_name
+     - principal_type
+     - hiveObject
+    """
+    pass
+
+  def grant_privileges(self, privileges):
+    """
+    Parameters:
+     - privileges
+    """
+    pass
+
+  def revoke_privileges(self, privileges):
+    """
+    Parameters:
+     - privileges
+    """
+    pass
+
 
 class Client(fb303.FacebookService.Client, Iface):
   """
@@ -1210,6 +1319,48 @@ class Client(fb303.FacebookService.Clien
       raise result.o2
     raise TApplicationException(TApplicationException.MISSING_RESULT, "get_partition failed: unknown result");
 
+  def get_partition_with_auth(self, db_name, tbl_name, part_vals, user_name, group_names):
+    """
+    Parameters:
+     - db_name
+     - tbl_name
+     - part_vals
+     - user_name
+     - group_names
+    """
+    self.send_get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names)
+    return self.recv_get_partition_with_auth()
+
+  def send_get_partition_with_auth(self, db_name, tbl_name, part_vals, user_name, group_names):
+    self._oprot.writeMessageBegin('get_partition_with_auth', TMessageType.CALL, self._seqid)
+    args = get_partition_with_auth_args()
+    args.db_name = db_name
+    args.tbl_name = tbl_name
+    args.part_vals = part_vals
+    args.user_name = user_name
+    args.group_names = group_names
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_get_partition_with_auth(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = get_partition_with_auth_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    if result.o2 != None:
+      raise result.o2
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "get_partition_with_auth failed: unknown result");
+
   def get_partition_by_name(self, db_name, tbl_name, part_name):
     """
     Parameters:
@@ -1286,6 +1437,48 @@ class Client(fb303.FacebookService.Clien
       raise result.o2
     raise TApplicationException(TApplicationException.MISSING_RESULT, "get_partitions failed: unknown result");
 
+  def get_partitions_with_auth(self, db_name, tbl_name, max_parts, user_name, group_names):
+    """
+    Parameters:
+     - db_name
+     - tbl_name
+     - max_parts
+     - user_name
+     - group_names
+    """
+    self.send_get_partitions_with_auth(db_name, tbl_name, max_parts, user_name, group_names)
+    return self.recv_get_partitions_with_auth()
+
+  def send_get_partitions_with_auth(self, db_name, tbl_name, max_parts, user_name, group_names):
+    self._oprot.writeMessageBegin('get_partitions_with_auth', TMessageType.CALL, self._seqid)
+    args = get_partitions_with_auth_args()
+    args.db_name = db_name
+    args.tbl_name = tbl_name
+    args.max_parts = max_parts
+    args.user_name = user_name
+    args.group_names = group_names
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_get_partitions_with_auth(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = get_partitions_with_auth_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    if result.o2 != None:
+      raise result.o2
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "get_partitions_with_auth failed: unknown result");
+
   def get_partition_names(self, db_name, tbl_name, max_parts):
     """
     Parameters:
@@ -1360,6 +1553,50 @@ class Client(fb303.FacebookService.Clien
       raise result.o1
     raise TApplicationException(TApplicationException.MISSING_RESULT, "get_partitions_ps failed: unknown result");
 
+  def get_partitions_ps_with_auth(self, db_name, tbl_name, part_vals, max_parts, user_name, group_names):
+    """
+    Parameters:
+     - db_name
+     - tbl_name
+     - part_vals
+     - max_parts
+     - user_name
+     - group_names
+    """
+    self.send_get_partitions_ps_with_auth(db_name, tbl_name, part_vals, max_parts, user_name, group_names)
+    return self.recv_get_partitions_ps_with_auth()
+
+  def send_get_partitions_ps_with_auth(self, db_name, tbl_name, part_vals, max_parts, user_name, group_names):
+    self._oprot.writeMessageBegin('get_partitions_ps_with_auth', TMessageType.CALL, self._seqid)
+    args = get_partitions_ps_with_auth_args()
+    args.db_name = db_name
+    args.tbl_name = tbl_name
+    args.part_vals = part_vals
+    args.max_parts = max_parts
+    args.user_name = user_name
+    args.group_names = group_names
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_get_partitions_ps_with_auth(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = get_partitions_ps_with_auth_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    if result.o2 != None:
+      raise result.o2
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "get_partitions_ps_with_auth failed: unknown result");
+
   def get_partition_names_ps(self, db_name, tbl_name, part_vals, max_parts):
     """
     Parameters:
@@ -1800,86 +2037,410 @@ class Client(fb303.FacebookService.Clien
       raise result.o2
     raise TApplicationException(TApplicationException.MISSING_RESULT, "get_index_names failed: unknown result");
 
+  def create_role(self, role):
+    """
+    Parameters:
+     - role
+    """
+    self.send_create_role(role)
+    return self.recv_create_role()
 
-class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
-  def __init__(self, handler):
-    fb303.FacebookService.Processor.__init__(self, handler)
-    self._processMap["create_database"] = Processor.process_create_database
-    self._processMap["get_database"] = Processor.process_get_database
-    self._processMap["drop_database"] = Processor.process_drop_database
-    self._processMap["get_databases"] = Processor.process_get_databases
-    self._processMap["get_all_databases"] = Processor.process_get_all_databases
-    self._processMap["alter_database"] = Processor.process_alter_database
-    self._processMap["get_type"] = Processor.process_get_type
-    self._processMap["create_type"] = Processor.process_create_type
-    self._processMap["drop_type"] = Processor.process_drop_type
-    self._processMap["get_type_all"] = Processor.process_get_type_all
-    self._processMap["get_fields"] = Processor.process_get_fields
-    self._processMap["get_schema"] = Processor.process_get_schema
-    self._processMap["create_table"] = Processor.process_create_table
-    self._processMap["drop_table"] = Processor.process_drop_table
-    self._processMap["get_tables"] = Processor.process_get_tables
-    self._processMap["get_all_tables"] = Processor.process_get_all_tables
-    self._processMap["get_table"] = Processor.process_get_table
-    self._processMap["alter_table"] = Processor.process_alter_table
-    self._processMap["add_partition"] = Processor.process_add_partition
-    self._processMap["append_partition"] = Processor.process_append_partition
-    self._processMap["append_partition_by_name"] = Processor.process_append_partition_by_name
-    self._processMap["drop_partition"] = Processor.process_drop_partition
-    self._processMap["drop_partition_by_name"] = Processor.process_drop_partition_by_name
-    self._processMap["get_partition"] = Processor.process_get_partition
-    self._processMap["get_partition_by_name"] = Processor.process_get_partition_by_name
-    self._processMap["get_partitions"] = Processor.process_get_partitions
-    self._processMap["get_partition_names"] = Processor.process_get_partition_names
-    self._processMap["get_partitions_ps"] = Processor.process_get_partitions_ps
-    self._processMap["get_partition_names_ps"] = Processor.process_get_partition_names_ps
-    self._processMap["get_partitions_by_filter"] = Processor.process_get_partitions_by_filter
-    self._processMap["alter_partition"] = Processor.process_alter_partition
-    self._processMap["get_config_value"] = Processor.process_get_config_value
-    self._processMap["partition_name_to_vals"] = Processor.process_partition_name_to_vals
-    self._processMap["partition_name_to_spec"] = Processor.process_partition_name_to_spec
-    self._processMap["add_index"] = Processor.process_add_index
-    self._processMap["alter_index"] = Processor.process_alter_index
-    self._processMap["drop_index_by_name"] = Processor.process_drop_index_by_name
-    self._processMap["get_index_by_name"] = Processor.process_get_index_by_name
-    self._processMap["get_indexes"] = Processor.process_get_indexes
-    self._processMap["get_index_names"] = Processor.process_get_index_names
+  def send_create_role(self, role):
+    self._oprot.writeMessageBegin('create_role', TMessageType.CALL, self._seqid)
+    args = create_role_args()
+    args.role = role
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process(self, iprot, oprot):
-    (name, type, seqid) = iprot.readMessageBegin()
-    if name not in self._processMap:
-      iprot.skip(TType.STRUCT)
-      iprot.readMessageEnd()
-      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
-      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
-      x.write(oprot)
-      oprot.writeMessageEnd()
-      oprot.trans.flush()
-      return
-    else:
-      self._processMap[name](self, seqid, iprot, oprot)
-    return True
+  def recv_create_role(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = create_role_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "create_role failed: unknown result");
 
-  def process_create_database(self, seqid, iprot, oprot):
-    args = create_database_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = create_database_result()
-    try:
-      self._handler.create_database(args.database)
-    except AlreadyExistsException, o1:
-      result.o1 = o1
-    except InvalidObjectException, o2:
-      result.o2 = o2
-    except MetaException, o3:
-      result.o3 = o3
-    oprot.writeMessageBegin("create_database", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def drop_role(self, role_name):
+    """
+    Parameters:
+     - role_name
+    """
+    self.send_drop_role(role_name)
+    return self.recv_drop_role()
 
-  def process_get_database(self, seqid, iprot, oprot):
-    args = get_database_args()
+  def send_drop_role(self, role_name):
+    self._oprot.writeMessageBegin('drop_role', TMessageType.CALL, self._seqid)
+    args = drop_role_args()
+    args.role_name = role_name
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_drop_role(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = drop_role_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "drop_role failed: unknown result");
+
+  def grant_role(self, role_name, principal_name, principal_type, grantor, grantorType, grant_option):
+    """
+    Parameters:
+     - role_name
+     - principal_name
+     - principal_type
+     - grantor
+     - grantorType
+     - grant_option
+    """
+    self.send_grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option)
+    return self.recv_grant_role()
+
+  def send_grant_role(self, role_name, principal_name, principal_type, grantor, grantorType, grant_option):
+    self._oprot.writeMessageBegin('grant_role', TMessageType.CALL, self._seqid)
+    args = grant_role_args()
+    args.role_name = role_name
+    args.principal_name = principal_name
+    args.principal_type = principal_type
+    args.grantor = grantor
+    args.grantorType = grantorType
+    args.grant_option = grant_option
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_grant_role(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = grant_role_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "grant_role failed: unknown result");
+
+  def revoke_role(self, role_name, principal_name, principal_type):
+    """
+    Parameters:
+     - role_name
+     - principal_name
+     - principal_type
+    """
+    self.send_revoke_role(role_name, principal_name, principal_type)
+    return self.recv_revoke_role()
+
+  def send_revoke_role(self, role_name, principal_name, principal_type):
+    self._oprot.writeMessageBegin('revoke_role', TMessageType.CALL, self._seqid)
+    args = revoke_role_args()
+    args.role_name = role_name
+    args.principal_name = principal_name
+    args.principal_type = principal_type
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_revoke_role(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = revoke_role_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "revoke_role failed: unknown result");
+
+  def list_roles(self, principal_name, principal_type):
+    """
+    Parameters:
+     - principal_name
+     - principal_type
+    """
+    self.send_list_roles(principal_name, principal_type)
+    return self.recv_list_roles()
+
+  def send_list_roles(self, principal_name, principal_type):
+    self._oprot.writeMessageBegin('list_roles', TMessageType.CALL, self._seqid)
+    args = list_roles_args()
+    args.principal_name = principal_name
+    args.principal_type = principal_type
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_list_roles(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = list_roles_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "list_roles failed: unknown result");
+
+  def get_privilege_set(self, hiveObject, user_name, group_names):
+    """
+    Parameters:
+     - hiveObject
+     - user_name
+     - group_names
+    """
+    self.send_get_privilege_set(hiveObject, user_name, group_names)
+    return self.recv_get_privilege_set()
+
+  def send_get_privilege_set(self, hiveObject, user_name, group_names):
+    self._oprot.writeMessageBegin('get_privilege_set', TMessageType.CALL, self._seqid)
+    args = get_privilege_set_args()
+    args.hiveObject = hiveObject
+    args.user_name = user_name
+    args.group_names = group_names
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_get_privilege_set(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = get_privilege_set_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "get_privilege_set failed: unknown result");
+
+  def list_privileges(self, principal_name, principal_type, hiveObject):
+    """
+    Parameters:
+     - principal_name
+     - principal_type
+     - hiveObject
+    """
+    self.send_list_privileges(principal_name, principal_type, hiveObject)
+    return self.recv_list_privileges()
+
+  def send_list_privileges(self, principal_name, principal_type, hiveObject):
+    self._oprot.writeMessageBegin('list_privileges', TMessageType.CALL, self._seqid)
+    args = list_privileges_args()
+    args.principal_name = principal_name
+    args.principal_type = principal_type
+    args.hiveObject = hiveObject
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_list_privileges(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = list_privileges_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "list_privileges failed: unknown result");
+
+  def grant_privileges(self, privileges):
+    """
+    Parameters:
+     - privileges
+    """
+    self.send_grant_privileges(privileges)
+    return self.recv_grant_privileges()
+
+  def send_grant_privileges(self, privileges):
+    self._oprot.writeMessageBegin('grant_privileges', TMessageType.CALL, self._seqid)
+    args = grant_privileges_args()
+    args.privileges = privileges
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_grant_privileges(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = grant_privileges_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "grant_privileges failed: unknown result");
+
+  def revoke_privileges(self, privileges):
+    """
+    Parameters:
+     - privileges
+    """
+    self.send_revoke_privileges(privileges)
+    return self.recv_revoke_privileges()
+
+  def send_revoke_privileges(self, privileges):
+    self._oprot.writeMessageBegin('revoke_privileges', TMessageType.CALL, self._seqid)
+    args = revoke_privileges_args()
+    args.privileges = privileges
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_revoke_privileges(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = revoke_privileges_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.o1 != None:
+      raise result.o1
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "revoke_privileges failed: unknown result");
+
+
+class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
+  def __init__(self, handler):
+    fb303.FacebookService.Processor.__init__(self, handler)
+    self._processMap["create_database"] = Processor.process_create_database
+    self._processMap["get_database"] = Processor.process_get_database
+    self._processMap["drop_database"] = Processor.process_drop_database
+    self._processMap["get_databases"] = Processor.process_get_databases
+    self._processMap["get_all_databases"] = Processor.process_get_all_databases
+    self._processMap["alter_database"] = Processor.process_alter_database
+    self._processMap["get_type"] = Processor.process_get_type
+    self._processMap["create_type"] = Processor.process_create_type
+    self._processMap["drop_type"] = Processor.process_drop_type
+    self._processMap["get_type_all"] = Processor.process_get_type_all
+    self._processMap["get_fields"] = Processor.process_get_fields
+    self._processMap["get_schema"] = Processor.process_get_schema
+    self._processMap["create_table"] = Processor.process_create_table
+    self._processMap["drop_table"] = Processor.process_drop_table
+    self._processMap["get_tables"] = Processor.process_get_tables
+    self._processMap["get_all_tables"] = Processor.process_get_all_tables
+    self._processMap["get_table"] = Processor.process_get_table
+    self._processMap["alter_table"] = Processor.process_alter_table
+    self._processMap["add_partition"] = Processor.process_add_partition
+    self._processMap["append_partition"] = Processor.process_append_partition
+    self._processMap["append_partition_by_name"] = Processor.process_append_partition_by_name
+    self._processMap["drop_partition"] = Processor.process_drop_partition
+    self._processMap["drop_partition_by_name"] = Processor.process_drop_partition_by_name
+    self._processMap["get_partition"] = Processor.process_get_partition
+    self._processMap["get_partition_with_auth"] = Processor.process_get_partition_with_auth
+    self._processMap["get_partition_by_name"] = Processor.process_get_partition_by_name
+    self._processMap["get_partitions"] = Processor.process_get_partitions
+    self._processMap["get_partitions_with_auth"] = Processor.process_get_partitions_with_auth
+    self._processMap["get_partition_names"] = Processor.process_get_partition_names
+    self._processMap["get_partitions_ps"] = Processor.process_get_partitions_ps
+    self._processMap["get_partitions_ps_with_auth"] = Processor.process_get_partitions_ps_with_auth
+    self._processMap["get_partition_names_ps"] = Processor.process_get_partition_names_ps
+    self._processMap["get_partitions_by_filter"] = Processor.process_get_partitions_by_filter
+    self._processMap["alter_partition"] = Processor.process_alter_partition
+    self._processMap["get_config_value"] = Processor.process_get_config_value
+    self._processMap["partition_name_to_vals"] = Processor.process_partition_name_to_vals
+    self._processMap["partition_name_to_spec"] = Processor.process_partition_name_to_spec
+    self._processMap["add_index"] = Processor.process_add_index
+    self._processMap["alter_index"] = Processor.process_alter_index
+    self._processMap["drop_index_by_name"] = Processor.process_drop_index_by_name
+    self._processMap["get_index_by_name"] = Processor.process_get_index_by_name
+    self._processMap["get_indexes"] = Processor.process_get_indexes
+    self._processMap["get_index_names"] = Processor.process_get_index_names
+    self._processMap["create_role"] = Processor.process_create_role
+    self._processMap["drop_role"] = Processor.process_drop_role
+    self._processMap["grant_role"] = Processor.process_grant_role
+    self._processMap["revoke_role"] = Processor.process_revoke_role
+    self._processMap["list_roles"] = Processor.process_list_roles
+    self._processMap["get_privilege_set"] = Processor.process_get_privilege_set
+    self._processMap["list_privileges"] = Processor.process_list_privileges
+    self._processMap["grant_privileges"] = Processor.process_grant_privileges
+    self._processMap["revoke_privileges"] = Processor.process_revoke_privileges
+
+  def process(self, iprot, oprot):
+    (name, type, seqid) = iprot.readMessageBegin()
+    if name not in self._processMap:
+      iprot.skip(TType.STRUCT)
+      iprot.readMessageEnd()
+      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
+      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
+      x.write(oprot)
+      oprot.writeMessageEnd()
+      oprot.trans.flush()
+      return
+    else:
+      self._processMap[name](self, seqid, iprot, oprot)
+    return True
+
+  def process_create_database(self, seqid, iprot, oprot):
+    args = create_database_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = create_database_result()
+    try:
+      self._handler.create_database(args.database)
+    except AlreadyExistsException, o1:
+      result.o1 = o1
+    except InvalidObjectException, o2:
+      result.o2 = o2
+    except MetaException, o3:
+      result.o3 = o3
+    oprot.writeMessageBegin("create_database", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_get_database(self, seqid, iprot, oprot):
+    args = get_database_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = get_database_result()
@@ -2254,6 +2815,22 @@ class Processor(fb303.FacebookService.Pr
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
+  def process_get_partition_with_auth(self, seqid, iprot, oprot):
+    args = get_partition_with_auth_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = get_partition_with_auth_result()
+    try:
+      result.success = self._handler.get_partition_with_auth(args.db_name, args.tbl_name, args.part_vals, args.user_name, args.group_names)
+    except MetaException, o1:
+      result.o1 = o1
+    except NoSuchObjectException, o2:
+      result.o2 = o2
+    oprot.writeMessageBegin("get_partition_with_auth", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
   def process_get_partition_by_name(self, seqid, iprot, oprot):
     args = get_partition_by_name_args()
     args.read(iprot)
@@ -2286,11 +2863,27 @@ class Processor(fb303.FacebookService.Pr
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_get_partition_names(self, seqid, iprot, oprot):
-    args = get_partition_names_args()
+  def process_get_partitions_with_auth(self, seqid, iprot, oprot):
+    args = get_partitions_with_auth_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = get_partition_names_result()
+    result = get_partitions_with_auth_result()
+    try:
+      result.success = self._handler.get_partitions_with_auth(args.db_name, args.tbl_name, args.max_parts, args.user_name, args.group_names)
+    except NoSuchObjectException, o1:
+      result.o1 = o1
+    except MetaException, o2:
+      result.o2 = o2
+    oprot.writeMessageBegin("get_partitions_with_auth", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_get_partition_names(self, seqid, iprot, oprot):
+    args = get_partition_names_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = get_partition_names_result()
     try:
       result.success = self._handler.get_partition_names(args.db_name, args.tbl_name, args.max_parts)
     except MetaException, o2:
@@ -2314,6 +2907,22 @@ class Processor(fb303.FacebookService.Pr
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
+  def process_get_partitions_ps_with_auth(self, seqid, iprot, oprot):
+    args = get_partitions_ps_with_auth_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = get_partitions_ps_with_auth_result()
+    try:
+      result.success = self._handler.get_partitions_ps_with_auth(args.db_name, args.tbl_name, args.part_vals, args.max_parts, args.user_name, args.group_names)
+    except NoSuchObjectException, o1:
+      result.o1 = o1
+    except MetaException, o2:
+      result.o2 = o2
+    oprot.writeMessageBegin("get_partitions_ps_with_auth", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
   def process_get_partition_names_ps(self, seqid, iprot, oprot):
     args = get_partition_names_ps_args()
     args.read(iprot)
@@ -2498,6 +3107,132 @@ class Processor(fb303.FacebookService.Pr
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
+  def process_create_role(self, seqid, iprot, oprot):
+    args = create_role_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = create_role_result()
+    try:
+      result.success = self._handler.create_role(args.role)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("create_role", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_drop_role(self, seqid, iprot, oprot):
+    args = drop_role_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = drop_role_result()
+    try:
+      result.success = self._handler.drop_role(args.role_name)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("drop_role", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_grant_role(self, seqid, iprot, oprot):
+    args = grant_role_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = grant_role_result()
+    try:
+      result.success = self._handler.grant_role(args.role_name, args.principal_name, args.principal_type, args.grantor, args.grantorType, args.grant_option)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("grant_role", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_revoke_role(self, seqid, iprot, oprot):
+    args = revoke_role_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = revoke_role_result()
+    try:
+      result.success = self._handler.revoke_role(args.role_name, args.principal_name, args.principal_type)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("revoke_role", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_list_roles(self, seqid, iprot, oprot):
+    args = list_roles_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = list_roles_result()
+    try:
+      result.success = self._handler.list_roles(args.principal_name, args.principal_type)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("list_roles", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_get_privilege_set(self, seqid, iprot, oprot):
+    args = get_privilege_set_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = get_privilege_set_result()
+    try:
+      result.success = self._handler.get_privilege_set(args.hiveObject, args.user_name, args.group_names)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("get_privilege_set", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_list_privileges(self, seqid, iprot, oprot):
+    args = list_privileges_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = list_privileges_result()
+    try:
+      result.success = self._handler.list_privileges(args.principal_name, args.principal_type, args.hiveObject)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("list_privileges", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_grant_privileges(self, seqid, iprot, oprot):
+    args = grant_privileges_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = grant_privileges_result()
+    try:
+      result.success = self._handler.grant_privileges(args.privileges)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("grant_privileges", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_revoke_privileges(self, seqid, iprot, oprot):
+    args = revoke_privileges_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = revoke_privileges_result()
+    try:
+      result.success = self._handler.revoke_privileges(args.privileges)
+    except MetaException, o1:
+      result.o1 = o1
+    oprot.writeMessageBegin("revoke_privileges", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
 
 # HELPER FUNCTIONS AND STRUCTURES
 
@@ -3035,10 +3770,10 @@ class get_databases_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype115, _size112) = iprot.readListBegin()
-          for _i116 in xrange(_size112):
-            _elem117 = iprot.readString();
-            self.success.append(_elem117)
+          (_etype177, _size174) = iprot.readListBegin()
+          for _i178 in xrange(_size174):
+            _elem179 = iprot.readString();
+            self.success.append(_elem179)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -3061,8 +3796,8 @@ class get_databases_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter118 in self.success:
-        oprot.writeString(iter118)
+      for iter180 in self.success:
+        oprot.writeString(iter180)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.o1 != None:
@@ -3155,10 +3890,10 @@ class get_all_databases_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype122, _size119) = iprot.readListBegin()
-          for _i123 in xrange(_size119):
-            _elem124 = iprot.readString();
-            self.success.append(_elem124)
+          (_etype184, _size181) = iprot.readListBegin()
+          for _i185 in xrange(_size181):
+            _elem186 = iprot.readString();
+            self.success.append(_elem186)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -3181,8 +3916,8 @@ class get_all_databases_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter125 in self.success:
-        oprot.writeString(iter125)
+      for iter187 in self.success:
+        oprot.writeString(iter187)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.o1 != None:
@@ -3882,12 +4617,12 @@ class get_type_all_result:
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype127, _vtype128, _size126 ) = iprot.readMapBegin() 
-          for _i130 in xrange(_size126):
-            _key131 = iprot.readString();
-            _val132 = Type()
-            _val132.read(iprot)
-            self.success[_key131] = _val132
+          (_ktype189, _vtype190, _size188 ) = iprot.readMapBegin() 
+          for _i192 in xrange(_size188):
+            _key193 = iprot.readString();
+            _val194 = Type()
+            _val194.read(iprot)
+            self.success[_key193] = _val194
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
@@ -3910,9 +4645,9 @@ class get_type_all_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
-      for kiter133,viter134 in self.success.items():
-        oprot.writeString(kiter133)
-        viter134.write(oprot)
+      for kiter195,viter196 in self.success.items():
+        oprot.writeString(kiter195)
+        viter196.write(oprot)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.o2 != None:
@@ -4041,11 +4776,11 @@ class get_fields_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype138, _size135) = iprot.readListBegin()
-          for _i139 in xrange(_size135):
-            _elem140 = FieldSchema()
-            _elem140.read(iprot)
-            self.success.append(_elem140)
+          (_etype200, _size197) = iprot.readListBegin()
+          for _i201 in xrange(_size197):
+            _elem202 = FieldSchema()
+            _elem202.read(iprot)
+            self.success.append(_elem202)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -4080,8 +4815,8 @@ class get_fields_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter141 in self.success:
-        iter141.write(oprot)
+      for iter203 in self.success:
+        iter203.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.o1 != None:
@@ -4218,11 +4953,11 @@ class get_schema_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype145, _size142) = iprot.readListBegin()
-          for _i146 in xrange(_size142):
-            _elem147 = FieldSchema()
-            _elem147.read(iprot)
-            self.success.append(_elem147)
+          (_etype207, _size204) = iprot.readListBegin()
+          for _i208 in xrange(_size204):
+            _elem209 = FieldSchema()
+            _elem209.read(iprot)
+            self.success.append(_elem209)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -4257,8 +4992,8 @@ class get_schema_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter148 in self.success:
-        iter148.write(oprot)
+      for iter210 in self.success:
+        iter210.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.o1 != None:
@@ -4704,10 +5439,10 @@ class get_tables_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype152, _size149) = iprot.readListBegin()
-          for _i153 in xrange(_size149):
-            _elem154 = iprot.readString();
-            self.success.append(_elem154)
+          (_etype214, _size211) = iprot.readListBegin()
+          for _i215 in xrange(_size211):
+            _elem216 = iprot.readString();
+            self.success.append(_elem216)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -4730,8 +5465,8 @@ class get_tables_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter155 in self.success:
-        oprot.writeString(iter155)
+      for iter217 in self.success:
+        oprot.writeString(iter217)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.o1 != None:
@@ -4842,10 +5577,10 @@ class get_all_tables_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype159, _size156) = iprot.readListBegin()
-          for _i160 in xrange(_size156):
-            _elem161 = iprot.readString();
-            self.success.append(_elem161)
+          (_etype221, _size218) = iprot.readListBegin()
+          for _i222 in xrange(_size218):
+            _elem223 = iprot.readString();
+            self.success.append(_elem223)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -4868,8 +5603,8 @@ class get_all_tables_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter162 in self.success:
-        oprot.writeString(iter162)
+      for iter224 in self.success:
+        oprot.writeString(iter224)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.o1 != None:
@@ -5406,10 +6141,10 @@ class append_partition_args:
       elif fid == 3:
         if ftype == TType.LIST:
           self.part_vals = []
-          (_etype166, _size163) = iprot.readListBegin()
-          for _i167 in xrange(_size163):
-            _elem168 = iprot.readString();
-            self.part_vals.append(_elem168)
+          (_etype228, _size225) = iprot.readListBegin()
+          for _i229 in xrange(_size225):
+            _elem230 = iprot.readString();
+            self.part_vals.append(_elem230)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -5434,8 +6169,8 @@ class append_partition_args:
     if self.part_vals != None:
       oprot.writeFieldBegin('part_vals', TType.LIST, 3)
       oprot.writeListBegin(TType.STRING, len(self.part_vals))
-      for iter169 in self.part_vals:
-        oprot.writeString(iter169)
+      for iter231 in self.part_vals:
+        oprot.writeString(iter231)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -5779,10 +6514,10 @@ class drop_partition_args:
       elif fid == 3:
         if ftype == TType.LIST:
           self.part_vals = []
-          (_etype173, _size170) = iprot.readListBegin()
-          for _i174 in xrange(_size170):
-            _elem175 = iprot.readString();
-            self.part_vals.append(_elem175)
+          (_etype235, _size232) = iprot.readListBegin()
+          for _i236 in xrange(_size232):
+            _elem237 = iprot.readString();
+            self.part_vals.append(_elem237)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -5812,8 +6547,8 @@ class drop_partition_args:
     if self.part_vals != None:
       oprot.writeFieldBegin('part_vals', TType.LIST, 3)
       oprot.writeListBegin(TType.STRING, len(self.part_vals))
-      for iter176 in self.part_vals:
-        oprot.writeString(iter176)
+      for iter238 in self.part_vals:
+        oprot.writeString(iter238)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.deleteData != None:
@@ -6142,10 +6877,10 @@ class get_partition_args:
       elif fid == 3:
         if ftype == TType.LIST:
           self.part_vals = []
-          (_etype180, _size177) = iprot.readListBegin()
-          for _i181 in xrange(_size177):
-            _elem182 = iprot.readString();
-            self.part_vals.append(_elem182)
+          (_etype242, _size239) = iprot.readListBegin()
+          for _i243 in xrange(_size239):
+            _elem244 = iprot.readString();
+            self.part_vals.append(_elem244)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6170,8 +6905,8 @@ class get_partition_args:
     if self.part_vals != None:
       oprot.writeFieldBegin('part_vals', TType.LIST, 3)
       oprot.writeListBegin(TType.STRING, len(self.part_vals))
-      for iter183 in self.part_vals:
-        oprot.writeString(iter183)
+      for iter245 in self.part_vals:
+        oprot.writeString(iter245)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -6276,25 +7011,31 @@ class get_partition_result:
   def __ne__(self, other):
     return not (self == other)
 
-class get_partition_by_name_args:
+class get_partition_with_auth_args:
   """
   Attributes:
    - db_name
    - tbl_name
-   - part_name
+   - part_vals
+   - user_name
+   - group_names
   """
 
   thrift_spec = (
     None, # 0
     (1, TType.STRING, 'db_name', None, None, ), # 1
     (2, TType.STRING, 'tbl_name', None, None, ), # 2
-    (3, TType.STRING, 'part_name', None, None, ), # 3
+    (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3
+    (4, TType.STRING, 'user_name', None, None, ), # 4
+    (5, TType.LIST, 'group_names', (TType.STRING,None), None, ), # 5
   )
 
-  def __init__(self, db_name=None, tbl_name=None, part_name=None,):
+  def __init__(self, db_name=None, tbl_name=None, part_vals=None, user_name=None, group_names=None,):
     self.db_name = db_name
     self.tbl_name = tbl_name
-    self.part_name = part_name
+    self.part_vals = part_vals
+    self.user_name = user_name
+    self.group_names = group_names
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -6316,8 +7057,28 @@ class get_partition_by_name_args:
         else:
           iprot.skip(ftype)
       elif fid == 3:
+        if ftype == TType.LIST:
+          self.part_vals = []
+          (_etype249, _size246) = iprot.readListBegin()
+          for _i250 in xrange(_size246):
+            _elem251 = iprot.readString();
+            self.part_vals.append(_elem251)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
         if ftype == TType.STRING:
-          self.part_name = iprot.readString();
+          self.user_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.LIST:
+          self.group_names = []
+          (_etype255, _size252) = iprot.readListBegin()
+          for _i256 in xrange(_size252):
+            _elem257 = iprot.readString();
+            self.group_names.append(_elem257)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
@@ -6329,7 +7090,7 @@ class get_partition_by_name_args:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_partition_by_name_args')
+    oprot.writeStructBegin('get_partition_with_auth_args')
     if self.db_name != None:
       oprot.writeFieldBegin('db_name', TType.STRING, 1)
       oprot.writeString(self.db_name)
@@ -6338,9 +7099,23 @@ class get_partition_by_name_args:
       oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
       oprot.writeString(self.tbl_name)
       oprot.writeFieldEnd()
-    if self.part_name != None:
-      oprot.writeFieldBegin('part_name', TType.STRING, 3)
-      oprot.writeString(self.part_name)
+    if self.part_vals != None:
+      oprot.writeFieldBegin('part_vals', TType.LIST, 3)
+      oprot.writeListBegin(TType.STRING, len(self.part_vals))
+      for iter258 in self.part_vals:
+        oprot.writeString(iter258)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.user_name != None:
+      oprot.writeFieldBegin('user_name', TType.STRING, 4)
+      oprot.writeString(self.user_name)
+      oprot.writeFieldEnd()
+    if self.group_names != None:
+      oprot.writeFieldBegin('group_names', TType.LIST, 5)
+      oprot.writeListBegin(TType.STRING, len(self.group_names))
+      for iter259 in self.group_names:
+        oprot.writeString(iter259)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
@@ -6359,7 +7134,7 @@ class get_partition_by_name_args:
   def __ne__(self, other):
     return not (self == other)
 
-class get_partition_by_name_result:
+class get_partition_with_auth_result:
   """
   Attributes:
    - success
@@ -6414,7 +7189,7 @@ class get_partition_by_name_result:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_partition_by_name_result')
+    oprot.writeStructBegin('get_partition_with_auth_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
@@ -6444,25 +7219,25 @@ class get_partition_by_name_result:
   def __ne__(self, other):
     return not (self == other)
 
-class get_partitions_args:
+class get_partition_by_name_args:
   """
   Attributes:
    - db_name
    - tbl_name
-   - max_parts
+   - part_name
   """
 
   thrift_spec = (
     None, # 0
     (1, TType.STRING, 'db_name', None, None, ), # 1
     (2, TType.STRING, 'tbl_name', None, None, ), # 2
-    (3, TType.I16, 'max_parts', None, -1, ), # 3
+    (3, TType.STRING, 'part_name', None, None, ), # 3
   )
 
-  def __init__(self, db_name=None, tbl_name=None, max_parts=thrift_spec[3][4],):
+  def __init__(self, db_name=None, tbl_name=None, part_name=None,):
     self.db_name = db_name
     self.tbl_name = tbl_name
-    self.max_parts = max_parts
+    self.part_name = part_name
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -6484,8 +7259,8 @@ class get_partitions_args:
         else:
           iprot.skip(ftype)
       elif fid == 3:
-        if ftype == TType.I16:
-          self.max_parts = iprot.readI16();
+        if ftype == TType.STRING:
+          self.part_name = iprot.readString();
         else:
           iprot.skip(ftype)
       else:
@@ -6497,7 +7272,7 @@ class get_partitions_args:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_partitions_args')
+    oprot.writeStructBegin('get_partition_by_name_args')
     if self.db_name != None:
       oprot.writeFieldBegin('db_name', TType.STRING, 1)
       oprot.writeString(self.db_name)
@@ -6506,9 +7281,9 @@ class get_partitions_args:
       oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
       oprot.writeString(self.tbl_name)
       oprot.writeFieldEnd()
-    if self.max_parts != None:
-      oprot.writeFieldBegin('max_parts', TType.I16, 3)
-      oprot.writeI16(self.max_parts)
+    if self.part_name != None:
+      oprot.writeFieldBegin('part_name', TType.STRING, 3)
+      oprot.writeString(self.part_name)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
@@ -6527,7 +7302,7 @@ class get_partitions_args:
   def __ne__(self, other):
     return not (self == other)
 
-class get_partitions_result:
+class get_partition_by_name_result:
   """
   Attributes:
    - success
@@ -6536,9 +7311,9 @@ class get_partitions_result:
   """
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Partition, Partition.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
-    (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2
+    (0, TType.STRUCT, 'success', (Partition, Partition.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'o2', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 2
   )
 
   def __init__(self, success=None, o1=None, o2=None,):
@@ -6556,25 +7331,20 @@ class get_partitions_result:
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.LIST:
-          self.success = []
-          (_etype187, _size184) = iprot.readListBegin()
-          for _i188 in xrange(_size184):
-            _elem189 = Partition()
-            _elem189.read(iprot)
-            self.success.append(_elem189)
-          iprot.readListEnd()
+        if ftype == TType.STRUCT:
+          self.success = Partition()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.o1 = NoSuchObjectException()
+          self.o1 = MetaException()
           self.o1.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRUCT:
-          self.o2 = MetaException()
+          self.o2 = NoSuchObjectException()
           self.o2.read(iprot)
         else:
           iprot.skip(ftype)
@@ -6587,13 +7357,10 @@ class get_partitions_result:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_partitions_result')
+    oprot.writeStructBegin('get_partition_by_name_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter190 in self.success:
-        iter190.write(oprot)
-      oprot.writeListEnd()
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
       oprot.writeFieldEnd()
     if self.o1 != None:
       oprot.writeFieldBegin('o1', TType.STRUCT, 1)
@@ -6620,7 +7387,7 @@ class get_partitions_result:
   def __ne__(self, other):
     return not (self == other)
 
-class get_partition_names_args:
+class get_partitions_args:
   """
   Attributes:
    - db_name
@@ -6673,7 +7440,7 @@ class get_partition_names_args:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_partition_names_args')
+    oprot.writeStructBegin('get_partitions_args')
     if self.db_name != None:
       oprot.writeFieldBegin('db_name', TType.STRING, 1)
       oprot.writeString(self.db_name)
@@ -6703,20 +7470,23 @@ class get_partition_names_args:
   def __ne__(self, other):
     return not (self == other)
 
-class get_partition_names_result:
+class get_partitions_result:
   """
   Attributes:
    - success
+   - o1
    - o2
   """
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
-    (1, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 1
+    (0, TType.LIST, 'success', (TType.STRUCT,(Partition, Partition.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2
   )
 
-  def __init__(self, success=None, o2=None,):
+  def __init__(self, success=None, o1=None, o2=None,):
     self.success = success
+    self.o1 = o1
     self.o2 = o2
 
   def read(self, iprot):
@@ -6731,15 +7501,22 @@ class get_partition_names_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype194, _size191) = iprot.readListBegin()
-          for _i195 in xrange(_size191):
-            _elem196 = iprot.readString();
-            self.success.append(_elem196)
+          (_etype263, _size260) = iprot.readListBegin()
+          for _i264 in xrange(_size260):
+            _elem265 = Partition()
+            _elem265.read(iprot)
+            self.success.append(_elem265)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
+          self.o1 = NoSuchObjectException()
+          self.o1.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
           self.o2 = MetaException()
           self.o2.read(iprot)
         else:
@@ -6753,16 +7530,20 @@ class get_partition_names_result:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_partition_names_result')
+    oprot.writeStructBegin('get_partitions_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter197 in self.success:
-        oprot.writeString(iter197)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter266 in self.success:
+        iter266.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
+    if self.o1 != None:
+      oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+      self.o1.write(oprot)
+      oprot.writeFieldEnd()
     if self.o2 != None:
-      oprot.writeFieldBegin('o2', TType.STRUCT, 1)
+      oprot.writeFieldBegin('o2', TType.STRUCT, 2)
       self.o2.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -6782,28 +7563,31 @@ class get_partition_names_result:
   def __ne__(self, other):
     return not (self == other)
 
-class get_partitions_ps_args:
+class get_partitions_with_auth_args:
   """
   Attributes:
    - db_name
    - tbl_name
-   - part_vals
    - max_parts
+   - user_name
+   - group_names
   """
 
   thrift_spec = (
     None, # 0
     (1, TType.STRING, 'db_name', None, None, ), # 1
     (2, TType.STRING, 'tbl_name', None, None, ), # 2
-    (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3
-    (4, TType.I16, 'max_parts', None, -1, ), # 4
+    (3, TType.I16, 'max_parts', None, -1, ), # 3
+    (4, TType.STRING, 'user_name', None, None, ), # 4
+    (5, TType.LIST, 'group_names', (TType.STRING,None), None, ), # 5
   )
 
-  def __init__(self, db_name=None, tbl_name=None, part_vals=None, max_parts=thrift_spec[4][4],):
+  def __init__(self, db_name=None, tbl_name=None, max_parts=thrift_spec[3][4], user_name=None, group_names=None,):
     self.db_name = db_name
     self.tbl_name = tbl_name
-    self.part_vals = part_vals
     self.max_parts = max_parts
+    self.user_name = user_name
+    self.group_names = group_names
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -6825,18 +7609,2078 @@ class get_partitions_ps_args:
         else:
           iprot.skip(ftype)
       elif fid == 3:
+        if ftype == TType.I16:
+          self.max_parts = iprot.readI16();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.user_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
         if ftype == TType.LIST:
-          self.part_vals = []
-          (_etype201, _size198) = iprot.readListBegin()
-          for _i202 in xrange(_size198):
-            _elem203 = iprot.readString();
-            self.part_vals.append(_elem203)
+          self.group_names = []
+          (_etype270, _size267) = iprot.readListBegin()
+          for _i271 in xrange(_size267):
+            _elem272 = iprot.readString();
+            self.group_names.append(_elem272)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partitions_with_auth_args')
+    if self.db_name != None:
+      oprot.writeFieldBegin('db_name', TType.STRING, 1)
+      oprot.writeString(self.db_name)
+      oprot.writeFieldEnd()
+    if self.tbl_name != None:
+      oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
+      oprot.writeString(self.tbl_name)
+      oprot.writeFieldEnd()
+    if self.max_parts != None:
+      oprot.writeFieldBegin('max_parts', TType.I16, 3)
+      oprot.writeI16(self.max_parts)
+      oprot.writeFieldEnd()
+    if self.user_name != None:
+      oprot.writeFieldBegin('user_name', TType.STRING, 4)
+      oprot.writeString(self.user_name)
+      oprot.writeFieldEnd()
+    if self.group_names != None:
+      oprot.writeFieldBegin('group_names', TType.LIST, 5)
+      oprot.writeListBegin(TType.STRING, len(self.group_names))
+      for iter273 in self.group_names:
+        oprot.writeString(iter273)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partitions_with_auth_result:
+  """
+  Attributes:
+   - success
+   - o1
+   - o2
+  """
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Partition, Partition.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, success=None, o1=None, o2=None,):
+    self.success = success
+    self.o1 = o1
+    self.o2 = o2
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype277, _size274) = iprot.readListBegin()
+          for _i278 in xrange(_size274):
+            _elem279 = Partition()
+            _elem279.read(iprot)
+            self.success.append(_elem279)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.o1 = NoSuchObjectException()
+          self.o1.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.o2 = MetaException()
+          self.o2.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partitions_with_auth_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter280 in self.success:
+        iter280.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.o1 != None:
+      oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+      self.o1.write(oprot)
+      oprot.writeFieldEnd()
+    if self.o2 != None:
+      oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+      self.o2.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partition_names_args:
+  """
+  Attributes:
+   - db_name
+   - tbl_name
+   - max_parts
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'db_name', None, None, ), # 1
+    (2, TType.STRING, 'tbl_name', None, None, ), # 2
+    (3, TType.I16, 'max_parts', None, -1, ), # 3
+  )
+
+  def __init__(self, db_name=None, tbl_name=None, max_parts=thrift_spec[3][4],):
+    self.db_name = db_name
+    self.tbl_name = tbl_name
+    self.max_parts = max_parts
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.db_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.tbl_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I16:
+          self.max_parts = iprot.readI16();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partition_names_args')
+    if self.db_name != None:
+      oprot.writeFieldBegin('db_name', TType.STRING, 1)
+      oprot.writeString(self.db_name)
+      oprot.writeFieldEnd()
+    if self.tbl_name != None:
+      oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
+      oprot.writeString(self.tbl_name)
+      oprot.writeFieldEnd()
+    if self.max_parts != None:
+      oprot.writeFieldBegin('max_parts', TType.I16, 3)
+      oprot.writeI16(self.max_parts)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partition_names_result:
+  """
+  Attributes:
+   - success
+   - o2
+  """
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
+    (1, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, o2=None,):
+    self.success = success
+    self.o2 = o2
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype284, _size281) = iprot.readListBegin()
+          for _i285 in xrange(_size281):
+            _elem286 = iprot.readString();
+            self.success.append(_elem286)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.o2 = MetaException()
+          self.o2.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partition_names_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRING, len(self.success))
+      for iter287 in self.success:
+        oprot.writeString(iter287)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.o2 != None:
+      oprot.writeFieldBegin('o2', TType.STRUCT, 1)
+      self.o2.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partitions_ps_args:
+  """
+  Attributes:
+   - db_name
+   - tbl_name
+   - part_vals
+   - max_parts
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'db_name', None, None, ), # 1
+    (2, TType.STRING, 'tbl_name', None, None, ), # 2
+    (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3
+    (4, TType.I16, 'max_parts', None, -1, ), # 4
+  )
+
+  def __init__(self, db_name=None, tbl_name=None, part_vals=None, max_parts=thrift_spec[4][4],):
+    self.db_name = db_name
+    self.tbl_name = tbl_name
+    self.part_vals = part_vals
+    self.max_parts = max_parts
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.db_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.tbl_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.LIST:
+          self.part_vals = []
+          (_etype291, _size288) = iprot.readListBegin()
+          for _i292 in xrange(_size288):
+            _elem293 = iprot.readString();
+            self.part_vals.append(_elem293)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I16:
+          self.max_parts = iprot.readI16();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partitions_ps_args')
+    if self.db_name != None:
+      oprot.writeFieldBegin('db_name', TType.STRING, 1)
+      oprot.writeString(self.db_name)
+      oprot.writeFieldEnd()
+    if self.tbl_name != None:
+      oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
+      oprot.writeString(self.tbl_name)
+      oprot.writeFieldEnd()
+    if self.part_vals != None:
+      oprot.writeFieldBegin('part_vals', TType.LIST, 3)
+      oprot.writeListBegin(TType.STRING, len(self.part_vals))
+      for iter294 in self.part_vals:
+        oprot.writeString(iter294)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.max_parts != None:
+      oprot.writeFieldBegin('max_parts', TType.I16, 4)
+      oprot.writeI16(self.max_parts)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partitions_ps_result:
+  """
+  Attributes:
+   - success
+   - o1
+  """
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Partition, Partition.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, o1=None,):
+    self.success = success
+    self.o1 = o1
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype298, _size295) = iprot.readListBegin()
+          for _i299 in xrange(_size295):
+            _elem300 = Partition()
+            _elem300.read(iprot)
+            self.success.append(_elem300)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.o1 = MetaException()
+          self.o1.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partitions_ps_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter301 in self.success:
+        iter301.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.o1 != None:
+      oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+      self.o1.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partitions_ps_with_auth_args:
+  """
+  Attributes:
+   - db_name
+   - tbl_name
+   - part_vals
+   - max_parts
+   - user_name
+   - group_names
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'db_name', None, None, ), # 1
+    (2, TType.STRING, 'tbl_name', None, None, ), # 2
+    (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3
+    (4, TType.I16, 'max_parts', None, -1, ), # 4
+    (5, TType.STRING, 'user_name', None, None, ), # 5
+    (6, TType.LIST, 'group_names', (TType.STRING,None), None, ), # 6
+  )
+
+  def __init__(self, db_name=None, tbl_name=None, part_vals=None, max_parts=thrift_spec[4][4], user_name=None, group_names=None,):
+    self.db_name = db_name
+    self.tbl_name = tbl_name
+    self.part_vals = part_vals
+    self.max_parts = max_parts
+    self.user_name = user_name
+    self.group_names = group_names
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.db_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.tbl_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.LIST:
+          self.part_vals = []
+          (_etype305, _size302) = iprot.readListBegin()
+          for _i306 in xrange(_size302):
+            _elem307 = iprot.readString();
+            self.part_vals.append(_elem307)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I16:
+          self.max_parts = iprot.readI16();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
+          self.user_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.LIST:
+          self.group_names = []
+          (_etype311, _size308) = iprot.readListBegin()
+          for _i312 in xrange(_size308):
+            _elem313 = iprot.readString();
+            self.group_names.append(_elem313)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partitions_ps_with_auth_args')
+    if self.db_name != None:
+      oprot.writeFieldBegin('db_name', TType.STRING, 1)
+      oprot.writeString(self.db_name)
+      oprot.writeFieldEnd()
+    if self.tbl_name != None:
+      oprot.writeFieldBegin('tbl_name', TType.STRING, 2)
+      oprot.writeString(self.tbl_name)
+      oprot.writeFieldEnd()
+    if self.part_vals != None:
+      oprot.writeFieldBegin('part_vals', TType.LIST, 3)
+      oprot.writeListBegin(TType.STRING, len(self.part_vals))
+      for iter314 in self.part_vals:
+        oprot.writeString(iter314)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.max_parts != None:
+      oprot.writeFieldBegin('max_parts', TType.I16, 4)
+      oprot.writeI16(self.max_parts)
+      oprot.writeFieldEnd()
+    if self.user_name != None:
+      oprot.writeFieldBegin('user_name', TType.STRING, 5)
+      oprot.writeString(self.user_name)
+      oprot.writeFieldEnd()
+    if self.group_names != None:
+      oprot.writeFieldBegin('group_names', TType.LIST, 6)
+      oprot.writeListBegin(TType.STRING, len(self.group_names))
+      for iter315 in self.group_names:
+        oprot.writeString(iter315)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partitions_ps_with_auth_result:
+  """
+  Attributes:
+   - success
+   - o1
+   - o2
+  """
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Partition, Partition.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, success=None, o1=None, o2=None,):
+    self.success = success
+    self.o1 = o1
+    self.o2 = o2
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype319, _size316) = iprot.readListBegin()
+          for _i320 in xrange(_size316):
+            _elem321 = Partition()
+            _elem321.read(iprot)
+            self.success.append(_elem321)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.o1 = NoSuchObjectException()
+          self.o1.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.o2 = MetaException()
+          self.o2.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partitions_ps_with_auth_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter322 in self.success:
+        iter322.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.o1 != None:
+      oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+      self.o1.write(oprot)
+      oprot.writeFieldEnd()
+    if self.o2 != None:
+      oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+      self.o2.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+    def validate(self):
+      return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_partition_names_ps_args:
+  """
+  Attributes:
+   - db_name
+   - tbl_name
+   - part_vals
+   - max_parts
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'db_name', None, None, ), # 1
+    (2, TType.STRING, 'tbl_name', None, None, ), # 2
+    (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3
+    (4, TType.I16, 'max_parts', None, -1, ), # 4
+  )
+
+  def __init__(self, db_name=None, tbl_name=None, part_vals=None, max_parts=thrift_spec[4][4],):
+    self.db_name = db_name
+    self.tbl_name = tbl_name
+    self.part_vals = part_vals
+    self.max_parts = max_parts
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.db_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.tbl_name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.LIST:
+          self.part_vals = []
+          (_etype326, _size323) = iprot.readListBegin()
+          for _i327 in xrange(_size323):
+            _elem328 = iprot.readString();
+            self.part_vals.append(_elem328)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I16:
+          self.max_parts = iprot.readI16();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_partition_names_ps_args')
+    if self.db_name != None:

[... 3267 lines stripped ...]


Mime
View raw message