http://git-wip-us.apache.org/repos/asf/hive/blob/93b9cdd6/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
----------------------------------------------------------------------
diff --cc 
standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
index 0000000,a5bcc10..0af7238
mode 000000,100644..100644
--- 
a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
+++ 
b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
@@@ -1,0 -1,48956 +1,49183 @@@
+ #
+ # Autogenerated by Thrift Compiler (0.9.3)
+ #
+ # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ #
+ #  options string: py
+ #
+ 
+ from thrift.Thrift import TType, TMessageType, TException, 
TApplicationException
+ import fb303.FacebookService
+ import logging
+ from ttypes import *
+ from thrift.Thrift import TProcessor
+ from thrift.transport import TTransport
+ from thrift.protocol import TBinaryProtocol, TProtocol
+ try:
+   from thrift.protocol import fastbinary
+ except:
+   fastbinary = None
+ 
+ 
+ class Iface(fb303.FacebookService.Iface):
+   """
+   This interface is live.
+   """
+   def getMetaConf(self, key):
+     """
+     Parameters:
+      - key
+     """
+     pass
+ 
+   def setMetaConf(self, key, value):
+     """
+     Parameters:
+      - key
+      - value
+     """
+     pass
+ 
+   def create_catalog(self, catalog):
+     """
+     Parameters:
+      - catalog
+     """
+     pass
+ 
+   def alter_catalog(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def get_catalog(self, catName):
+     """
+     Parameters:
+      - catName
+     """
+     pass
+ 
+   def get_catalogs(self):
+     pass
+ 
+   def drop_catalog(self, catName):
+     """
+     Parameters:
+      - catName
+     """
+     pass
+ 
+   def create_database(self, database):
+     """
+     Parameters:
+      - database
+     """
+     pass
+ 
+   def get_database(self, name):
+     """
+     Parameters:
+      - name
+     """
+     pass
+ 
+   def drop_database(self, name, deleteData, cascade):
+     """
+     Parameters:
+      - name
+      - deleteData
+      - cascade
+     """
+     pass
+ 
+   def get_databases(self, pattern):
+     """
+     Parameters:
+      - pattern
+     """
+     pass
+ 
+   def get_all_databases(self):
+     pass
+ 
+   def alter_database(self, dbname, db):
+     """
+     Parameters:
+      - dbname
+      - db
+     """
+     pass
+ 
+   def get_type(self, name):
+     """
+     Parameters:
+      - name
+     """
+     pass
+ 
+   def create_type(self, type):
+     """
+     Parameters:
+      - type
+     """
+     pass
+ 
+   def drop_type(self, type):
+     """
+     Parameters:
+      - type
+     """
+     pass
+ 
+   def get_type_all(self, name):
+     """
+     Parameters:
+      - name
+     """
+     pass
+ 
+   def get_fields(self, db_name, table_name):
+     """
+     Parameters:
+      - db_name
+      - table_name
+     """
+     pass
+ 
+   def get_fields_with_environment_context(self, db_name, table_name, 
environment_context):
+     """
+     Parameters:
+      - db_name
+      - table_name
+      - environment_context
+     """
+     pass
+ 
+   def get_schema(self, db_name, table_name):
+     """
+     Parameters:
+      - db_name
+      - table_name
+     """
+     pass
+ 
+   def get_schema_with_environment_context(self, db_name, table_name, 
environment_context):
+     """
+     Parameters:
+      - db_name
+      - table_name
+      - environment_context
+     """
+     pass
+ 
+   def create_table(self, tbl):
+     """
+     Parameters:
+      - tbl
+     """
+     pass
+ 
+   def create_table_with_environment_context(self, tbl, environment_context):
+     """
+     Parameters:
+      - tbl
+      - environment_context
+     """
+     pass
+ 
+   def create_table_with_constraints(self, tbl, primaryKeys, foreignKeys, 
uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints):
+     """
+     Parameters:
+      - tbl
+      - primaryKeys
+      - foreignKeys
+      - uniqueConstraints
+      - notNullConstraints
+      - defaultConstraints
+      - checkConstraints
+     """
+     pass
+ 
+   def drop_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def add_primary_key(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def add_foreign_key(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def add_unique_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def add_not_null_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def add_default_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def add_check_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def drop_table(self, dbname, name, deleteData):
+     """
+     Parameters:
+      - dbname
+      - name
+      - deleteData
+     """
+     pass
+ 
+   def drop_table_with_environment_context(self, dbname, name, deleteData, 
environment_context):
+     """
+     Parameters:
+      - dbname
+      - name
+      - deleteData
+      - environment_context
+     """
+     pass
+ 
+   def truncate_table(self, dbName, tableName, partNames):
+     """
+     Parameters:
+      - dbName
+      - tableName
+      - partNames
+     """
+     pass
+ 
+   def get_tables(self, db_name, pattern):
+     """
+     Parameters:
+      - db_name
+      - pattern
+     """
+     pass
+ 
+   def get_tables_by_type(self, db_name, pattern, tableType):
+     """
+     Parameters:
+      - db_name
+      - pattern
+      - tableType
+     """
+     pass
+ 
+   def get_materialized_views_for_rewriting(self, db_name):
+     """
+     Parameters:
+      - db_name
+     """
+     pass
+ 
+   def get_table_meta(self, db_patterns, tbl_patterns, tbl_types):
+     """
+     Parameters:
+      - db_patterns
+      - tbl_patterns
+      - tbl_types
+     """
+     pass
+ 
+   def get_all_tables(self, db_name):
+     """
+     Parameters:
+      - db_name
+     """
+     pass
+ 
+   def get_table(self, dbname, tbl_name):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+     """
+     pass
+ 
+   def get_table_objects_by_name(self, dbname, tbl_names):
+     """
+     Parameters:
+      - dbname
+      - tbl_names
+     """
+     pass
+ 
+   def get_table_req(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def get_table_objects_by_name_req(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def get_materialization_invalidation_info(self, dbname, tbl_names):
+     """
+     Parameters:
+      - dbname
+      - tbl_names
+     """
+     pass
+ 
+   def update_creation_metadata(self, catName, dbname, tbl_name, 
creation_metadata):
+     """
+     Parameters:
+      - catName
+      - dbname
+      - tbl_name
+      - creation_metadata
+     """
+     pass
+ 
+   def get_table_names_by_filter(self, dbname, filter, max_tables):
+     """
+     Parameters:
+      - dbname
+      - filter
+      - max_tables
+     """
+     pass
+ 
+   def alter_table(self, dbname, tbl_name, new_tbl):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+      - new_tbl
+     """
+     pass
+ 
+   def alter_table_with_environment_context(self, dbname, tbl_name, new_tbl, 
environment_context):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+      - new_tbl
+      - environment_context
+     """
+     pass
+ 
+   def alter_table_with_cascade(self, dbname, tbl_name, new_tbl, cascade):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+      - new_tbl
+      - cascade
+     """
+     pass
+ 
+   def add_partition(self, new_part):
+     """
+     Parameters:
+      - new_part
+     """
+     pass
+ 
+   def add_partition_with_environment_context(self, new_part, 
environment_context):
+     """
+     Parameters:
+      - new_part
+      - environment_context
+     """
+     pass
+ 
+   def add_partitions(self, new_parts):
+     """
+     Parameters:
+      - new_parts
+     """
+     pass
+ 
+   def add_partitions_pspec(self, new_parts):
+     """
+     Parameters:
+      - new_parts
+     """
+     pass
+ 
+   def append_partition(self, db_name, tbl_name, part_vals):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+     """
+     pass
+ 
+   def add_partitions_req(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def append_partition_with_environment_context(self, db_name, tbl_name, 
part_vals, environment_context):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+      - environment_context
+     """
+     pass
+ 
+   def append_partition_by_name(self, db_name, tbl_name, part_name):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_name
+     """
+     pass
+ 
+   def append_partition_by_name_with_environment_context(self, db_name, 
tbl_name, part_name, environment_context):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_name
+      - environment_context
+     """
+     pass
+ 
+   def drop_partition(self, db_name, tbl_name, part_vals, deleteData):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+      - deleteData
+     """
+     pass
+ 
+   def drop_partition_with_environment_context(self, db_name, tbl_name, 
part_vals, deleteData, environment_context):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+      - deleteData
+      - environment_context
+     """
+     pass
+ 
+   def drop_partition_by_name(self, db_name, tbl_name, part_name, deleteData):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_name
+      - deleteData
+     """
+     pass
+ 
+   def drop_partition_by_name_with_environment_context(self, db_name, 
tbl_name, part_name, deleteData, environment_context):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_name
+      - deleteData
+      - environment_context
+     """
+     pass
+ 
+   def drop_partitions_req(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def get_partition(self, db_name, tbl_name, part_vals):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+     """
+     pass
+ 
+   def exchange_partition(self, partitionSpecs, source_db, source_table_name, 
dest_db, dest_table_name):
+     """
+     Parameters:
+      - partitionSpecs
+      - source_db
+      - source_table_name
+      - dest_db
+      - dest_table_name
+     """
+     pass
+ 
+   def exchange_partitions(self, partitionSpecs, source_db, source_table_name, 
dest_db, dest_table_name):
+     """
+     Parameters:
+      - partitionSpecs
+      - source_db
+      - source_table_name
+      - dest_db
+      - dest_table_name
+     """
+     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:
+      - db_name
+      - tbl_name
+      - part_name
+     """
+     pass
+ 
+   def get_partitions(self, db_name, tbl_name, max_parts):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - max_parts
+     """
+     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_partitions_pspec(self, db_name, tbl_name, max_parts):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - max_parts
+     """
+     pass
+ 
+   def get_partition_names(self, db_name, tbl_name, max_parts):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - max_parts
+     """
+     pass
+ 
+   def get_partition_values(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_partitions_ps(self, db_name, tbl_name, part_vals, max_parts):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+      - max_parts
+     """
+     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:
+      - db_name
+      - tbl_name
+      - part_vals
+      - max_parts
+     """
+     pass
+ 
+   def get_partitions_by_filter(self, db_name, tbl_name, filter, max_parts):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - filter
+      - max_parts
+     """
+     pass
+ 
+   def get_part_specs_by_filter(self, db_name, tbl_name, filter, max_parts):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - filter
+      - max_parts
+     """
+     pass
+ 
+   def get_partitions_by_expr(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def get_num_partitions_by_filter(self, db_name, tbl_name, filter):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - filter
+     """
+     pass
+ 
+   def get_partitions_by_names(self, db_name, tbl_name, names):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - names
+     """
+     pass
+ 
+   def alter_partition(self, db_name, tbl_name, new_part):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - new_part
+     """
+     pass
+ 
+   def alter_partitions(self, db_name, tbl_name, new_parts):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - new_parts
+     """
+     pass
+ 
+   def alter_partitions_with_environment_context(self, db_name, tbl_name, 
new_parts, environment_context):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - new_parts
+      - environment_context
+     """
+     pass
+ 
++  def alter_partitions_with_environment_context_req(self, req):
++    """
++    Parameters:
++     - req
++    """
++    pass
++
+   def alter_partition_with_environment_context(self, db_name, tbl_name, 
new_part, environment_context):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - new_part
+      - environment_context
+     """
+     pass
+ 
+   def rename_partition(self, db_name, tbl_name, part_vals, new_part):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+      - new_part
+     """
+     pass
+ 
+   def partition_name_has_valid_characters(self, part_vals, throw_exception):
+     """
+     Parameters:
+      - part_vals
+      - throw_exception
+     """
+     pass
+ 
+   def get_config_value(self, name, defaultValue):
+     """
+     Parameters:
+      - name
+      - defaultValue
+     """
+     pass
+ 
+   def partition_name_to_vals(self, part_name):
+     """
+     Parameters:
+      - part_name
+     """
+     pass
+ 
+   def partition_name_to_spec(self, part_name):
+     """
+     Parameters:
+      - part_name
+     """
+     pass
+ 
+   def markPartitionForEvent(self, db_name, tbl_name, part_vals, eventType):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+      - eventType
+     """
+     pass
+ 
+   def isPartitionMarkedForEvent(self, db_name, tbl_name, part_vals, 
eventType):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_vals
+      - eventType
+     """
+     pass
+ 
+   def get_primary_keys(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_foreign_keys(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_unique_constraints(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_not_null_constraints(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_default_constraints(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_check_constraints(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def update_table_column_statistics(self, stats_obj):
+     """
+     Parameters:
+      - stats_obj
+     """
+     pass
+ 
+   def update_partition_column_statistics(self, stats_obj):
+     """
+     Parameters:
+      - stats_obj
+     """
+     pass
+ 
+   def get_table_column_statistics(self, db_name, tbl_name, col_name):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - col_name
+     """
+     pass
+ 
+   def get_partition_column_statistics(self, db_name, tbl_name, part_name, 
col_name):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_name
+      - col_name
+     """
+     pass
+ 
+   def get_table_statistics_req(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_partitions_statistics_req(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_aggr_stats_for(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def set_aggr_stats_for(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def delete_partition_column_statistics(self, db_name, tbl_name, part_name, 
col_name):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - part_name
+      - col_name
+     """
+     pass
+ 
+   def delete_table_column_statistics(self, db_name, tbl_name, col_name):
+     """
+     Parameters:
+      - db_name
+      - tbl_name
+      - col_name
+     """
+     pass
+ 
+   def create_function(self, func):
+     """
+     Parameters:
+      - func
+     """
+     pass
+ 
+   def drop_function(self, dbName, funcName):
+     """
+     Parameters:
+      - dbName
+      - funcName
+     """
+     pass
+ 
+   def alter_function(self, dbName, funcName, newFunc):
+     """
+     Parameters:
+      - dbName
+      - funcName
+      - newFunc
+     """
+     pass
+ 
+   def get_functions(self, dbName, pattern):
+     """
+     Parameters:
+      - dbName
+      - pattern
+     """
+     pass
+ 
+   def get_function(self, dbName, funcName):
+     """
+     Parameters:
+      - dbName
+      - funcName
+     """
+     pass
+ 
+   def get_all_functions(self):
+     pass
+ 
+   def create_role(self, role):
+     """
+     Parameters:
+      - role
+     """
+     pass
+ 
+   def drop_role(self, role_name):
+     """
+     Parameters:
+      - role_name
+     """
+     pass
+ 
+   def get_role_names(self):
+     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 grant_revoke_role(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_principals_in_role(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_role_grants_for_principal(self, request):
+     """
+     Parameters:
+      - request
+     """
+     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
+ 
+   def grant_revoke_privileges(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def refresh_privileges(self, objToRefresh, authorizer, grantRequest):
+     """
+     Parameters:
+      - objToRefresh
+      - authorizer
+      - grantRequest
+     """
+     pass
+ 
+   def set_ugi(self, user_name, group_names):
+     """
+     Parameters:
+      - user_name
+      - group_names
+     """
+     pass
+ 
+   def get_delegation_token(self, token_owner, 
renewer_kerberos_principal_name):
+     """
+     Parameters:
+      - token_owner
+      - renewer_kerberos_principal_name
+     """
+     pass
+ 
+   def renew_delegation_token(self, token_str_form):
+     """
+     Parameters:
+      - token_str_form
+     """
+     pass
+ 
+   def cancel_delegation_token(self, token_str_form):
+     """
+     Parameters:
+      - token_str_form
+     """
+     pass
+ 
+   def add_token(self, token_identifier, delegation_token):
+     """
+     Parameters:
+      - token_identifier
+      - delegation_token
+     """
+     pass
+ 
+   def remove_token(self, token_identifier):
+     """
+     Parameters:
+      - token_identifier
+     """
+     pass
+ 
+   def get_token(self, token_identifier):
+     """
+     Parameters:
+      - token_identifier
+     """
+     pass
+ 
+   def get_all_token_identifiers(self):
+     pass
+ 
+   def add_master_key(self, key):
+     """
+     Parameters:
+      - key
+     """
+     pass
+ 
+   def update_master_key(self, seq_number, key):
+     """
+     Parameters:
+      - seq_number
+      - key
+     """
+     pass
+ 
+   def remove_master_key(self, key_seq):
+     """
+     Parameters:
+      - key_seq
+     """
+     pass
+ 
+   def get_master_keys(self):
+     pass
+ 
+   def get_open_txns(self):
+     pass
+ 
+   def get_open_txns_info(self):
+     pass
+ 
+   def open_txns(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def abort_txn(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def abort_txns(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def commit_txn(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def repl_tbl_writeid_state(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def get_valid_write_ids(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def allocate_table_write_ids(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def lock(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def check_lock(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def unlock(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def show_locks(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def heartbeat(self, ids):
+     """
+     Parameters:
+      - ids
+     """
+     pass
+ 
+   def heartbeat_txn_range(self, txns):
+     """
+     Parameters:
+      - txns
+     """
+     pass
+ 
+   def compact(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def compact2(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def show_compact(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def add_dynamic_partitions(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def get_next_notification(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def get_current_notificationEventId(self):
+     pass
+ 
+   def get_notification_events_count(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def fire_listener_event(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def flushCache(self):
+     pass
+ 
+   def add_write_notification_log(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def cm_recycle(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_file_metadata_by_expr(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def get_file_metadata(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def put_file_metadata(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def clear_file_metadata(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def cache_file_metadata(self, req):
+     """
+     Parameters:
+      - req
+     """
+     pass
+ 
+   def get_metastore_db_uuid(self):
+     pass
+ 
+   def create_resource_plan(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_resource_plan(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_active_resource_plan(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_all_resource_plans(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def alter_resource_plan(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def validate_resource_plan(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def drop_resource_plan(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def create_wm_trigger(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def alter_wm_trigger(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def drop_wm_trigger(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def get_triggers_for_resourceplan(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def create_wm_pool(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def alter_wm_pool(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def drop_wm_pool(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def create_or_update_wm_mapping(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def drop_wm_mapping(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def create_or_drop_wm_trigger_to_pool_mapping(self, request):
+     """
+     Parameters:
+      - request
+     """
+     pass
+ 
+   def create_ischema(self, schema):
+     """
+     Parameters:
+      - schema
+     """
+     pass
+ 
+   def alter_ischema(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def get_ischema(self, name):
+     """
+     Parameters:
+      - name
+     """
+     pass
+ 
+   def drop_ischema(self, name):
+     """
+     Parameters:
+      - name
+     """
+     pass
+ 
+   def add_schema_version(self, schemaVersion):
+     """
+     Parameters:
+      - schemaVersion
+     """
+     pass
+ 
+   def get_schema_version(self, schemaVersion):
+     """
+     Parameters:
+      - schemaVersion
+     """
+     pass
+ 
+   def get_schema_latest_version(self, schemaName):
+     """
+     Parameters:
+      - schemaName
+     """
+     pass
+ 
+   def get_schema_all_versions(self, schemaName):
+     """
+     Parameters:
+      - schemaName
+     """
+     pass
+ 
+   def drop_schema_version(self, schemaVersion):
+     """
+     Parameters:
+      - schemaVersion
+     """
+     pass
+ 
+   def get_schemas_by_cols(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def map_schema_version_to_serde(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def set_schema_version_state(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def add_serde(self, serde):
+     """
+     Parameters:
+      - serde
+     """
+     pass
+ 
+   def get_serde(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+   def get_lock_materialization_rebuild(self, dbName, tableName, txnId):
+     """
+     Parameters:
+      - dbName
+      - tableName
+      - txnId
+     """
+     pass
+ 
+   def heartbeat_lock_materialization_rebuild(self, dbName, tableName, txnId):
+     """
+     Parameters:
+      - dbName
+      - tableName
+      - txnId
+     """
+     pass
+ 
+   def add_runtime_stats(self, stat):
+     """
+     Parameters:
+      - stat
+     """
+     pass
+ 
+   def get_runtime_stats(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     pass
+ 
+ 
+ class Client(fb303.FacebookService.Client, Iface):
+   """
+   This interface is live.
+   """
+   def __init__(self, iprot, oprot=None):
+     fb303.FacebookService.Client.__init__(self, iprot, oprot)
+ 
+   def getMetaConf(self, key):
+     """
+     Parameters:
+      - key
+     """
+     self.send_getMetaConf(key)
+     return self.recv_getMetaConf()
+ 
+   def send_getMetaConf(self, key):
+     self._oprot.writeMessageBegin('getMetaConf', TMessageType.CALL, 
self._seqid)
+     args = getMetaConf_args()
+     args.key = key
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_getMetaConf(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = getMetaConf_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"getMetaConf failed: unknown result")
+ 
+   def setMetaConf(self, key, value):
+     """
+     Parameters:
+      - key
+      - value
+     """
+     self.send_setMetaConf(key, value)
+     self.recv_setMetaConf()
+ 
+   def send_setMetaConf(self, key, value):
+     self._oprot.writeMessageBegin('setMetaConf', TMessageType.CALL, 
self._seqid)
+     args = setMetaConf_args()
+     args.key = key
+     args.value = value
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_setMetaConf(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = setMetaConf_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     return
+ 
+   def create_catalog(self, catalog):
+     """
+     Parameters:
+      - catalog
+     """
+     self.send_create_catalog(catalog)
+     self.recv_create_catalog()
+ 
+   def send_create_catalog(self, catalog):
+     self._oprot.writeMessageBegin('create_catalog', TMessageType.CALL, 
self._seqid)
+     args = create_catalog_args()
+     args.catalog = catalog
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_create_catalog(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = create_catalog_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def alter_catalog(self, rqst):
+     """
+     Parameters:
+      - rqst
+     """
+     self.send_alter_catalog(rqst)
+     self.recv_alter_catalog()
+ 
+   def send_alter_catalog(self, rqst):
+     self._oprot.writeMessageBegin('alter_catalog', TMessageType.CALL, 
self._seqid)
+     args = alter_catalog_args()
+     args.rqst = rqst
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_alter_catalog(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = alter_catalog_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def get_catalog(self, catName):
+     """
+     Parameters:
+      - catName
+     """
+     self.send_get_catalog(catName)
+     return self.recv_get_catalog()
+ 
+   def send_get_catalog(self, catName):
+     self._oprot.writeMessageBegin('get_catalog', TMessageType.CALL, 
self._seqid)
+     args = get_catalog_args()
+     args.catName = catName
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_catalog(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_catalog_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_catalog failed: unknown result")
+ 
+   def get_catalogs(self):
+     self.send_get_catalogs()
+     return self.recv_get_catalogs()
+ 
+   def send_get_catalogs(self):
+     self._oprot.writeMessageBegin('get_catalogs', TMessageType.CALL, 
self._seqid)
+     args = get_catalogs_args()
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_catalogs(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_catalogs_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_catalogs failed: unknown result")
+ 
+   def drop_catalog(self, catName):
+     """
+     Parameters:
+      - catName
+     """
+     self.send_drop_catalog(catName)
+     self.recv_drop_catalog()
+ 
+   def send_drop_catalog(self, catName):
+     self._oprot.writeMessageBegin('drop_catalog', TMessageType.CALL, 
self._seqid)
+     args = drop_catalog_args()
+     args.catName = catName
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_drop_catalog(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = drop_catalog_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def create_database(self, database):
+     """
+     Parameters:
+      - database
+     """
+     self.send_create_database(database)
+     self.recv_create_database()
+ 
+   def send_create_database(self, database):
+     self._oprot.writeMessageBegin('create_database', TMessageType.CALL, 
self._seqid)
+     args = create_database_args()
+     args.database = database
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_create_database(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = create_database_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def get_database(self, name):
+     """
+     Parameters:
+      - name
+     """
+     self.send_get_database(name)
+     return self.recv_get_database()
+ 
+   def send_get_database(self, name):
+     self._oprot.writeMessageBegin('get_database', TMessageType.CALL, 
self._seqid)
+     args = get_database_args()
+     args.name = name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_database(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_database_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_database failed: unknown result")
+ 
+   def drop_database(self, name, deleteData, cascade):
+     """
+     Parameters:
+      - name
+      - deleteData
+      - cascade
+     """
+     self.send_drop_database(name, deleteData, cascade)
+     self.recv_drop_database()
+ 
+   def send_drop_database(self, name, deleteData, cascade):
+     self._oprot.writeMessageBegin('drop_database', TMessageType.CALL, 
self._seqid)
+     args = drop_database_args()
+     args.name = name
+     args.deleteData = deleteData
+     args.cascade = cascade
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_drop_database(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = drop_database_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def get_databases(self, pattern):
+     """
+     Parameters:
+      - pattern
+     """
+     self.send_get_databases(pattern)
+     return self.recv_get_databases()
+ 
+   def send_get_databases(self, pattern):
+     self._oprot.writeMessageBegin('get_databases', TMessageType.CALL, 
self._seqid)
+     args = get_databases_args()
+     args.pattern = pattern
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_databases(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_databases_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_databases failed: unknown result")
+ 
+   def get_all_databases(self):
+     self.send_get_all_databases()
+     return self.recv_get_all_databases()
+ 
+   def send_get_all_databases(self):
+     self._oprot.writeMessageBegin('get_all_databases', TMessageType.CALL, 
self._seqid)
+     args = get_all_databases_args()
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_all_databases(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_all_databases_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_all_databases failed: unknown result")
+ 
+   def alter_database(self, dbname, db):
+     """
+     Parameters:
+      - dbname
+      - db
+     """
+     self.send_alter_database(dbname, db)
+     self.recv_alter_database()
+ 
+   def send_alter_database(self, dbname, db):
+     self._oprot.writeMessageBegin('alter_database', TMessageType.CALL, 
self._seqid)
+     args = alter_database_args()
+     args.dbname = dbname
+     args.db = db
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_alter_database(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = alter_database_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def get_type(self, name):
+     """
+     Parameters:
+      - name
+     """
+     self.send_get_type(name)
+     return self.recv_get_type()
+ 
+   def send_get_type(self, name):
+     self._oprot.writeMessageBegin('get_type', TMessageType.CALL, self._seqid)
+     args = get_type_args()
+     args.name = name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_type(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_type_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_type failed: unknown result")
+ 
+   def create_type(self, type):
+     """
+     Parameters:
+      - type
+     """
+     self.send_create_type(type)
+     return self.recv_create_type()
+ 
+   def send_create_type(self, type):
+     self._oprot.writeMessageBegin('create_type', TMessageType.CALL, 
self._seqid)
+     args = create_type_args()
+     args.type = type
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_create_type(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = create_type_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"create_type failed: unknown result")
+ 
+   def drop_type(self, type):
+     """
+     Parameters:
+      - type
+     """
+     self.send_drop_type(type)
+     return self.recv_drop_type()
+ 
+   def send_drop_type(self, type):
+     self._oprot.writeMessageBegin('drop_type', TMessageType.CALL, self._seqid)
+     args = drop_type_args()
+     args.type = type
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_drop_type(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = drop_type_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"drop_type failed: unknown result")
+ 
+   def get_type_all(self, name):
+     """
+     Parameters:
+      - name
+     """
+     self.send_get_type_all(name)
+     return self.recv_get_type_all()
+ 
+   def send_get_type_all(self, name):
+     self._oprot.writeMessageBegin('get_type_all', TMessageType.CALL, 
self._seqid)
+     args = get_type_all_args()
+     args.name = name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_type_all(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_type_all_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o2 is not None:
+       raise result.o2
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_type_all failed: unknown result")
+ 
+   def get_fields(self, db_name, table_name):
+     """
+     Parameters:
+      - db_name
+      - table_name
+     """
+     self.send_get_fields(db_name, table_name)
+     return self.recv_get_fields()
+ 
+   def send_get_fields(self, db_name, table_name):
+     self._oprot.writeMessageBegin('get_fields', TMessageType.CALL, 
self._seqid)
+     args = get_fields_args()
+     args.db_name = db_name
+     args.table_name = table_name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_fields(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_fields_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_fields failed: unknown result")
+ 
+   def get_fields_with_environment_context(self, db_name, table_name, 
environment_context):
+     """
+     Parameters:
+      - db_name
+      - table_name
+      - environment_context
+     """
+     self.send_get_fields_with_environment_context(db_name, table_name, 
environment_context)
+     return self.recv_get_fields_with_environment_context()
+ 
+   def send_get_fields_with_environment_context(self, db_name, table_name, 
environment_context):
+     self._oprot.writeMessageBegin('get_fields_with_environment_context', 
TMessageType.CALL, self._seqid)
+     args = get_fields_with_environment_context_args()
+     args.db_name = db_name
+     args.table_name = table_name
+     args.environment_context = environment_context
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_fields_with_environment_context(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_fields_with_environment_context_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_fields_with_environment_context failed: unknown result")
+ 
+   def get_schema(self, db_name, table_name):
+     """
+     Parameters:
+      - db_name
+      - table_name
+     """
+     self.send_get_schema(db_name, table_name)
+     return self.recv_get_schema()
+ 
+   def send_get_schema(self, db_name, table_name):
+     self._oprot.writeMessageBegin('get_schema', TMessageType.CALL, 
self._seqid)
+     args = get_schema_args()
+     args.db_name = db_name
+     args.table_name = table_name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_schema(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_schema_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_schema failed: unknown result")
+ 
+   def get_schema_with_environment_context(self, db_name, table_name, 
environment_context):
+     """
+     Parameters:
+      - db_name
+      - table_name
+      - environment_context
+     """
+     self.send_get_schema_with_environment_context(db_name, table_name, 
environment_context)
+     return self.recv_get_schema_with_environment_context()
+ 
+   def send_get_schema_with_environment_context(self, db_name, table_name, 
environment_context):
+     self._oprot.writeMessageBegin('get_schema_with_environment_context', 
TMessageType.CALL, self._seqid)
+     args = get_schema_with_environment_context_args()
+     args.db_name = db_name
+     args.table_name = table_name
+     args.environment_context = environment_context
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_schema_with_environment_context(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_schema_with_environment_context_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_schema_with_environment_context failed: unknown result")
+ 
+   def create_table(self, tbl):
+     """
+     Parameters:
+      - tbl
+     """
+     self.send_create_table(tbl)
+     self.recv_create_table()
+ 
+   def send_create_table(self, tbl):
+     self._oprot.writeMessageBegin('create_table', TMessageType.CALL, 
self._seqid)
+     args = create_table_args()
+     args.tbl = tbl
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_create_table(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = create_table_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     if result.o4 is not None:
+       raise result.o4
+     return
+ 
+   def create_table_with_environment_context(self, tbl, environment_context):
+     """
+     Parameters:
+      - tbl
+      - environment_context
+     """
+     self.send_create_table_with_environment_context(tbl, environment_context)
+     self.recv_create_table_with_environment_context()
+ 
+   def send_create_table_with_environment_context(self, tbl, 
environment_context):
+     self._oprot.writeMessageBegin('create_table_with_environment_context', 
TMessageType.CALL, self._seqid)
+     args = create_table_with_environment_context_args()
+     args.tbl = tbl
+     args.environment_context = environment_context
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_create_table_with_environment_context(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = create_table_with_environment_context_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     if result.o4 is not None:
+       raise result.o4
+     return
+ 
+   def create_table_with_constraints(self, tbl, primaryKeys, foreignKeys, 
uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints):
+     """
+     Parameters:
+      - tbl
+      - primaryKeys
+      - foreignKeys
+      - uniqueConstraints
+      - notNullConstraints
+      - defaultConstraints
+      - checkConstraints
+     """
+     self.send_create_table_with_constraints(tbl, primaryKeys, foreignKeys, 
uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints)
+     self.recv_create_table_with_constraints()
+ 
+   def send_create_table_with_constraints(self, tbl, primaryKeys, foreignKeys, 
uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints):
+     self._oprot.writeMessageBegin('create_table_with_constraints', 
TMessageType.CALL, self._seqid)
+     args = create_table_with_constraints_args()
+     args.tbl = tbl
+     args.primaryKeys = primaryKeys
+     args.foreignKeys = foreignKeys
+     args.uniqueConstraints = uniqueConstraints
+     args.notNullConstraints = notNullConstraints
+     args.defaultConstraints = defaultConstraints
+     args.checkConstraints = checkConstraints
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_create_table_with_constraints(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = create_table_with_constraints_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     if result.o4 is not None:
+       raise result.o4
+     return
+ 
+   def drop_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_drop_constraint(req)
+     self.recv_drop_constraint()
+ 
+   def send_drop_constraint(self, req):
+     self._oprot.writeMessageBegin('drop_constraint', TMessageType.CALL, 
self._seqid)
+     args = drop_constraint_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_drop_constraint(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = drop_constraint_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def add_primary_key(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_add_primary_key(req)
+     self.recv_add_primary_key()
+ 
+   def send_add_primary_key(self, req):
+     self._oprot.writeMessageBegin('add_primary_key', TMessageType.CALL, 
self._seqid)
+     args = add_primary_key_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_primary_key(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_primary_key_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def add_foreign_key(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_add_foreign_key(req)
+     self.recv_add_foreign_key()
+ 
+   def send_add_foreign_key(self, req):
+     self._oprot.writeMessageBegin('add_foreign_key', TMessageType.CALL, 
self._seqid)
+     args = add_foreign_key_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_foreign_key(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_foreign_key_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def add_unique_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_add_unique_constraint(req)
+     self.recv_add_unique_constraint()
+ 
+   def send_add_unique_constraint(self, req):
+     self._oprot.writeMessageBegin('add_unique_constraint', TMessageType.CALL, 
self._seqid)
+     args = add_unique_constraint_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_unique_constraint(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_unique_constraint_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def add_not_null_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_add_not_null_constraint(req)
+     self.recv_add_not_null_constraint()
+ 
+   def send_add_not_null_constraint(self, req):
+     self._oprot.writeMessageBegin('add_not_null_constraint', 
TMessageType.CALL, self._seqid)
+     args = add_not_null_constraint_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_not_null_constraint(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_not_null_constraint_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def add_default_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_add_default_constraint(req)
+     self.recv_add_default_constraint()
+ 
+   def send_add_default_constraint(self, req):
+     self._oprot.writeMessageBegin('add_default_constraint', 
TMessageType.CALL, self._seqid)
+     args = add_default_constraint_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_default_constraint(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_default_constraint_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def add_check_constraint(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_add_check_constraint(req)
+     self.recv_add_check_constraint()
+ 
+   def send_add_check_constraint(self, req):
+     self._oprot.writeMessageBegin('add_check_constraint', TMessageType.CALL, 
self._seqid)
+     args = add_check_constraint_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_check_constraint(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_check_constraint_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def drop_table(self, dbname, name, deleteData):
+     """
+     Parameters:
+      - dbname
+      - name
+      - deleteData
+     """
+     self.send_drop_table(dbname, name, deleteData)
+     self.recv_drop_table()
+ 
+   def send_drop_table(self, dbname, name, deleteData):
+     self._oprot.writeMessageBegin('drop_table', TMessageType.CALL, 
self._seqid)
+     args = drop_table_args()
+     args.dbname = dbname
+     args.name = name
+     args.deleteData = deleteData
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_drop_table(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = drop_table_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def drop_table_with_environment_context(self, dbname, name, deleteData, 
environment_context):
+     """
+     Parameters:
+      - dbname
+      - name
+      - deleteData
+      - environment_context
+     """
+     self.send_drop_table_with_environment_context(dbname, name, deleteData, 
environment_context)
+     self.recv_drop_table_with_environment_context()
+ 
+   def send_drop_table_with_environment_context(self, dbname, name, 
deleteData, environment_context):
+     self._oprot.writeMessageBegin('drop_table_with_environment_context', 
TMessageType.CALL, self._seqid)
+     args = drop_table_with_environment_context_args()
+     args.dbname = dbname
+     args.name = name
+     args.deleteData = deleteData
+     args.environment_context = environment_context
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_drop_table_with_environment_context(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = drop_table_with_environment_context_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def truncate_table(self, dbName, tableName, partNames):
+     """
+     Parameters:
+      - dbName
+      - tableName
+      - partNames
+     """
+     self.send_truncate_table(dbName, tableName, partNames)
+     self.recv_truncate_table()
+ 
+   def send_truncate_table(self, dbName, tableName, partNames):
+     self._oprot.writeMessageBegin('truncate_table', TMessageType.CALL, 
self._seqid)
+     args = truncate_table_args()
+     args.dbName = dbName
+     args.tableName = tableName
+     args.partNames = partNames
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_truncate_table(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = truncate_table_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     return
+ 
+   def get_tables(self, db_name, pattern):
+     """
+     Parameters:
+      - db_name
+      - pattern
+     """
+     self.send_get_tables(db_name, pattern)
+     return self.recv_get_tables()
+ 
+   def send_get_tables(self, db_name, pattern):
+     self._oprot.writeMessageBegin('get_tables', TMessageType.CALL, 
self._seqid)
+     args = get_tables_args()
+     args.db_name = db_name
+     args.pattern = pattern
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_tables(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_tables_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_tables failed: unknown result")
+ 
+   def get_tables_by_type(self, db_name, pattern, tableType):
+     """
+     Parameters:
+      - db_name
+      - pattern
+      - tableType
+     """
+     self.send_get_tables_by_type(db_name, pattern, tableType)
+     return self.recv_get_tables_by_type()
+ 
+   def send_get_tables_by_type(self, db_name, pattern, tableType):
+     self._oprot.writeMessageBegin('get_tables_by_type', TMessageType.CALL, 
self._seqid)
+     args = get_tables_by_type_args()
+     args.db_name = db_name
+     args.pattern = pattern
+     args.tableType = tableType
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_tables_by_type(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_tables_by_type_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_tables_by_type failed: unknown result")
+ 
+   def get_materialized_views_for_rewriting(self, db_name):
+     """
+     Parameters:
+      - db_name
+     """
+     self.send_get_materialized_views_for_rewriting(db_name)
+     return self.recv_get_materialized_views_for_rewriting()
+ 
+   def send_get_materialized_views_for_rewriting(self, db_name):
+     self._oprot.writeMessageBegin('get_materialized_views_for_rewriting', 
TMessageType.CALL, self._seqid)
+     args = get_materialized_views_for_rewriting_args()
+     args.db_name = db_name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_materialized_views_for_rewriting(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_materialized_views_for_rewriting_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_materialized_views_for_rewriting failed: unknown result")
+ 
+   def get_table_meta(self, db_patterns, tbl_patterns, tbl_types):
+     """
+     Parameters:
+      - db_patterns
+      - tbl_patterns
+      - tbl_types
+     """
+     self.send_get_table_meta(db_patterns, tbl_patterns, tbl_types)
+     return self.recv_get_table_meta()
+ 
+   def send_get_table_meta(self, db_patterns, tbl_patterns, tbl_types):
+     self._oprot.writeMessageBegin('get_table_meta', TMessageType.CALL, 
self._seqid)
+     args = get_table_meta_args()
+     args.db_patterns = db_patterns
+     args.tbl_patterns = tbl_patterns
+     args.tbl_types = tbl_types
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_table_meta(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_table_meta_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_table_meta failed: unknown result")
+ 
+   def get_all_tables(self, db_name):
+     """
+     Parameters:
+      - db_name
+     """
+     self.send_get_all_tables(db_name)
+     return self.recv_get_all_tables()
+ 
+   def send_get_all_tables(self, db_name):
+     self._oprot.writeMessageBegin('get_all_tables', TMessageType.CALL, 
self._seqid)
+     args = get_all_tables_args()
+     args.db_name = db_name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_all_tables(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_all_tables_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_all_tables failed: unknown result")
+ 
+   def get_table(self, dbname, tbl_name):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+     """
+     self.send_get_table(dbname, tbl_name)
+     return self.recv_get_table()
+ 
+   def send_get_table(self, dbname, tbl_name):
+     self._oprot.writeMessageBegin('get_table', TMessageType.CALL, self._seqid)
+     args = get_table_args()
+     args.dbname = dbname
+     args.tbl_name = tbl_name
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_table(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_table_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_table failed: unknown result")
+ 
+   def get_table_objects_by_name(self, dbname, tbl_names):
+     """
+     Parameters:
+      - dbname
+      - tbl_names
+     """
+     self.send_get_table_objects_by_name(dbname, tbl_names)
+     return self.recv_get_table_objects_by_name()
+ 
+   def send_get_table_objects_by_name(self, dbname, tbl_names):
+     self._oprot.writeMessageBegin('get_table_objects_by_name', 
TMessageType.CALL, self._seqid)
+     args = get_table_objects_by_name_args()
+     args.dbname = dbname
+     args.tbl_names = tbl_names
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_table_objects_by_name(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_table_objects_by_name_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_table_objects_by_name failed: unknown result")
+ 
+   def get_table_req(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_get_table_req(req)
+     return self.recv_get_table_req()
+ 
+   def send_get_table_req(self, req):
+     self._oprot.writeMessageBegin('get_table_req', TMessageType.CALL, 
self._seqid)
+     args = get_table_req_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_table_req(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_table_req_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_table_req failed: unknown result")
+ 
+   def get_table_objects_by_name_req(self, req):
+     """
+     Parameters:
+      - req
+     """
+     self.send_get_table_objects_by_name_req(req)
+     return self.recv_get_table_objects_by_name_req()
+ 
+   def send_get_table_objects_by_name_req(self, req):
+     self._oprot.writeMessageBegin('get_table_objects_by_name_req', 
TMessageType.CALL, self._seqid)
+     args = get_table_objects_by_name_req_args()
+     args.req = req
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_table_objects_by_name_req(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_table_objects_by_name_req_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_table_objects_by_name_req failed: unknown result")
+ 
+   def get_materialization_invalidation_info(self, dbname, tbl_names):
+     """
+     Parameters:
+      - dbname
+      - tbl_names
+     """
+     self.send_get_materialization_invalidation_info(dbname, tbl_names)
+     return self.recv_get_materialization_invalidation_info()
+ 
+   def send_get_materialization_invalidation_info(self, dbname, tbl_names):
+     self._oprot.writeMessageBegin('get_materialization_invalidation_info', 
TMessageType.CALL, self._seqid)
+     args = get_materialization_invalidation_info_args()
+     args.dbname = dbname
+     args.tbl_names = tbl_names
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_materialization_invalidation_info(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_materialization_invalidation_info_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_materialization_invalidation_info failed: unknown result")
+ 
+   def update_creation_metadata(self, catName, dbname, tbl_name, 
creation_metadata):
+     """
+     Parameters:
+      - catName
+      - dbname
+      - tbl_name
+      - creation_metadata
+     """
+     self.send_update_creation_metadata(catName, dbname, tbl_name, 
creation_metadata)
+     self.recv_update_creation_metadata()
+ 
+   def send_update_creation_metadata(self, catName, dbname, tbl_name, 
creation_metadata):
+     self._oprot.writeMessageBegin('update_creation_metadata', 
TMessageType.CALL, self._seqid)
+     args = update_creation_metadata_args()
+     args.catName = catName
+     args.dbname = dbname
+     args.tbl_name = tbl_name
+     args.creation_metadata = creation_metadata
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_update_creation_metadata(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = update_creation_metadata_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     return
+ 
+   def get_table_names_by_filter(self, dbname, filter, max_tables):
+     """
+     Parameters:
+      - dbname
+      - filter
+      - max_tables
+     """
+     self.send_get_table_names_by_filter(dbname, filter, max_tables)
+     return self.recv_get_table_names_by_filter()
+ 
+   def send_get_table_names_by_filter(self, dbname, filter, max_tables):
+     self._oprot.writeMessageBegin('get_table_names_by_filter', 
TMessageType.CALL, self._seqid)
+     args = get_table_names_by_filter_args()
+     args.dbname = dbname
+     args.filter = filter
+     args.max_tables = max_tables
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_get_table_names_by_filter(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = get_table_names_by_filter_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"get_table_names_by_filter failed: unknown result")
+ 
+   def alter_table(self, dbname, tbl_name, new_tbl):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+      - new_tbl
+     """
+     self.send_alter_table(dbname, tbl_name, new_tbl)
+     self.recv_alter_table()
+ 
+   def send_alter_table(self, dbname, tbl_name, new_tbl):
+     self._oprot.writeMessageBegin('alter_table', TMessageType.CALL, 
self._seqid)
+     args = alter_table_args()
+     args.dbname = dbname
+     args.tbl_name = tbl_name
+     args.new_tbl = new_tbl
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_alter_table(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = alter_table_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def alter_table_with_environment_context(self, dbname, tbl_name, new_tbl, 
environment_context):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+      - new_tbl
+      - environment_context
+     """
+     self.send_alter_table_with_environment_context(dbname, tbl_name, new_tbl, 
environment_context)
+     self.recv_alter_table_with_environment_context()
+ 
+   def send_alter_table_with_environment_context(self, dbname, tbl_name, 
new_tbl, environment_context):
+     self._oprot.writeMessageBegin('alter_table_with_environment_context', 
TMessageType.CALL, self._seqid)
+     args = alter_table_with_environment_context_args()
+     args.dbname = dbname
+     args.tbl_name = tbl_name
+     args.new_tbl = new_tbl
+     args.environment_context = environment_context
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_alter_table_with_environment_context(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = alter_table_with_environment_context_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def alter_table_with_cascade(self, dbname, tbl_name, new_tbl, cascade):
+     """
+     Parameters:
+      - dbname
+      - tbl_name
+      - new_tbl
+      - cascade
+     """
+     self.send_alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade)
+     self.recv_alter_table_with_cascade()
+ 
+   def send_alter_table_with_cascade(self, dbname, tbl_name, new_tbl, cascade):
+     self._oprot.writeMessageBegin('alter_table_with_cascade', 
TMessageType.CALL, self._seqid)
+     args = alter_table_with_cascade_args()
+     args.dbname = dbname
+     args.tbl_name = tbl_name
+     args.new_tbl = new_tbl
+     args.cascade = cascade
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_alter_table_with_cascade(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = alter_table_with_cascade_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     return
+ 
+   def add_partition(self, new_part):
+     """
+     Parameters:
+      - new_part
+     """
+     self.send_add_partition(new_part)
+     return self.recv_add_partition()
+ 
+   def send_add_partition(self, new_part):
+     self._oprot.writeMessageBegin('add_partition', TMessageType.CALL, 
self._seqid)
+     args = add_partition_args()
+     args.new_part = new_part
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_partition(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_partition_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"add_partition failed: unknown result")
+ 
+   def add_partition_with_environment_context(self, new_part, 
environment_context):
+     """
+     Parameters:
+      - new_part
+      - environment_context
+     """
+     self.send_add_partition_with_environment_context(new_part, 
environment_context)
+     return self.recv_add_partition_with_environment_context()
+ 
+   def send_add_partition_with_environment_context(self, new_part, 
environment_context):
+     self._oprot.writeMessageBegin('add_partition_with_environment_context', 
TMessageType.CALL, self._seqid)
+     args = add_partition_with_environment_context_args()
+     args.new_part = new_part
+     args.environment_context = environment_context
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     self._oprot.trans.flush()
+ 
+   def recv_add_partition_with_environment_context(self):
+     iprot = self._iprot
+     (fname, mtype, rseqid) = iprot.readMessageBegin()
+     if mtype == TMessageType.EXCEPTION:
+       x = TApplicationException()
+       x.read(iprot)
+       iprot.readMessageEnd()
+       raise x
+     result = add_partition_with_environment_context_result()
+     result.read(iprot)
+     iprot.readMessageEnd()
+     if result.success is not None:
+       return result.success
+     if result.o1 is not None:
+       raise result.o1
+     if result.o2 is not None:
+       raise result.o2
+     if result.o3 is not None:
+       raise result.o3
+     raise TApplicationException(TApplicationException.MISSING_RESULT, 
"add_partition_with_environment_context failed: unknown result")
+ 
+   def add_partitions(self, new_parts):
+     """
+     Parameters:
+      - new_parts
+     """
+     self.send_add_partitions(new_parts)
+     return self.recv_add_partitions()
+ 
+   def send_add_partitions(self, new_parts):
+     self._oprot.writeMessageBegin('add_partitions', TMessageType.CALL, 
self._seqid)
+     args = add_partitions_args()
+     args.new_parts = new_parts
+     args.write(self._oprot)
+     self._oprot.writeMessageEnd()
+     s

<TRUNCATED>

Reply via email to