OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
heavydb.thrift.Heavy.Processor Class Reference
+ Inheritance diagram for heavydb.thrift.Heavy.Processor:
+ Collaboration diagram for heavydb.thrift.Heavy.Processor:

Public Member Functions

def __init__
 
def on_message_begin
 
def process
 
def process_connect
 
def process_krb5_connect
 
def process_disconnect
 
def process_switch_database
 
def process_clone_session
 
def process_get_server_status
 
def process_get_status
 
def process_get_hardware_info
 
def process_get_tables
 
def process_get_tables_for_database
 
def process_get_physical_tables
 
def process_get_views
 
def process_get_tables_meta
 
def process_get_table_details
 
def process_get_table_details_for_database
 
def process_get_internal_table_details
 
def process_get_internal_table_details_for_database
 
def process_get_users
 
def process_get_databases
 
def process_get_version
 
def process_start_heap_profile
 
def process_stop_heap_profile
 
def process_get_heap_profile
 
def process_get_memory
 
def process_clear_cpu_memory
 
def process_clear_gpu_memory
 
def process_set_cur_session
 
def process_invalidate_cur_session
 
def process_set_table_epoch
 
def process_set_table_epoch_by_name
 
def process_get_table_epoch
 
def process_get_table_epoch_by_name
 
def process_get_table_epochs
 
def process_set_table_epochs
 
def process_get_session_info
 
def process_get_queries_info
 
def process_set_leaf_info
 
def process_sql_execute
 
def process_sql_execute_df
 
def process_sql_execute_gdf
 
def process_deallocate_df
 
def process_interrupt
 
def process_sql_validate
 
def process_get_completion_hints
 
def process_set_execution_mode
 
def process_render_vega
 
def process_get_result_row_for_pixel
 
def process_create_custom_expression
 
def process_get_custom_expressions
 
def process_update_custom_expression
 
def process_delete_custom_expressions
 
def process_get_dashboard
 
def process_get_dashboards
 
def process_create_dashboard
 
def process_replace_dashboard
 
def process_delete_dashboard
 
def process_share_dashboards
 
def process_delete_dashboards
 
def process_share_dashboard
 
def process_unshare_dashboard
 
def process_unshare_dashboards
 
def process_get_dashboard_grantees
 
def process_get_link_view
 
def process_create_link
 
def process_load_table_binary
 
def process_load_table_binary_columnar
 
def process_load_table_binary_arrow
 
def process_load_table
 
def process_detect_column_types
 
def process_create_table
 
def process_import_table
 
def process_import_geo_table
 
def process_import_table_status
 
def process_get_first_geo_file_in_archive
 
def process_get_all_files_in_archive
 
def process_get_layers_in_geo_file
 
def process_query_get_outer_fragment_count
 
def process_check_table_consistency
 
def process_start_query
 
def process_execute_query_step
 
def process_broadcast_serialized_rows
 
def process_start_render_query
 
def process_execute_next_render_step
 
def process_insert_data
 
def process_insert_chunks
 
def process_checkpoint
 
def process_get_roles
 
def process_get_db_objects_for_grantee
 
def process_get_db_object_privs
 
def process_get_all_roles_for_user
 
def process_get_all_effective_roles_for_user
 
def process_has_role
 
def process_has_object_privilege
 
def process_set_license_key
 
def process_get_license_claims
 
def process_get_device_parameters
 
def process_register_runtime_extension_functions
 
def process_get_table_function_names
 
def process_get_runtime_table_function_names
 
def process_get_table_function_details
 
def process_get_function_names
 
def process_get_runtime_function_names
 
def process_get_function_details
 
- Public Member Functions inherited from heavydb.thrift.Heavy.Iface
def connect
 
def krb5_connect
 
def disconnect
 
def switch_database
 
def clone_session
 
def get_server_status
 
def get_status
 
def get_hardware_info
 
def get_tables
 
def get_tables_for_database
 
def get_physical_tables
 
def get_views
 
def get_tables_meta
 
def get_table_details
 
def get_table_details_for_database
 
def get_internal_table_details
 
def get_internal_table_details_for_database
 
def get_users
 
def get_databases
 
def get_version
 
def start_heap_profile
 
def stop_heap_profile
 
def get_heap_profile
 
def get_memory
 
def clear_cpu_memory
 
def clear_gpu_memory
 
def set_cur_session
 
def invalidate_cur_session
 
def set_table_epoch
 
def set_table_epoch_by_name
 
def get_table_epoch
 
def get_table_epoch_by_name
 
def get_table_epochs
 
def set_table_epochs
 
def get_session_info
 
def get_queries_info
 
def set_leaf_info
 
def sql_execute
 
def sql_execute_df
 
def sql_execute_gdf
 
def deallocate_df
 
def interrupt
 
def sql_validate
 
def get_completion_hints
 
def set_execution_mode
 
def render_vega
 
def get_result_row_for_pixel
 
def create_custom_expression
 
def get_custom_expressions
 
def update_custom_expression
 
def delete_custom_expressions
 
def get_dashboard
 
def get_dashboards
 
def create_dashboard
 
def replace_dashboard
 
def delete_dashboard
 
def share_dashboards
 
def delete_dashboards
 
def share_dashboard
 
def unshare_dashboard
 
def unshare_dashboards
 
def get_dashboard_grantees
 
def get_link_view
 
def create_link
 
def load_table_binary
 
def load_table_binary_columnar
 
def load_table_binary_arrow
 
def load_table
 
def detect_column_types
 
def create_table
 
def import_table
 
def import_geo_table
 
def import_table_status
 
def get_first_geo_file_in_archive
 
def get_all_files_in_archive
 
def get_layers_in_geo_file
 
def query_get_outer_fragment_count
 
def check_table_consistency
 
def start_query
 
def execute_query_step
 
def broadcast_serialized_rows
 
def start_render_query
 
def execute_next_render_step
 
def insert_data
 
def insert_chunks
 
def checkpoint
 
def get_roles
 
def get_db_objects_for_grantee
 
def get_db_object_privs
 
def get_all_roles_for_user
 
def get_all_effective_roles_for_user
 
def has_role
 
def has_object_privilege
 
def set_license_key
 
def get_license_claims
 
def get_device_parameters
 
def register_runtime_extension_functions
 
def get_table_function_names
 
def get_runtime_table_function_names
 
def get_table_function_details
 
def get_function_names
 
def get_runtime_function_names
 
def get_function_details
 

Private Attributes

 _handler
 
 _processMap
 
 _on_message_begin
 

Detailed Description

Definition at line 4785 of file Heavy.py.

Constructor & Destructor Documentation

def heavydb.thrift.Heavy.Processor.__init__ (   self,
  handler 
)

Definition at line 4786 of file Heavy.py.

4787  def __init__(self, handler):
4788  self._handler = handler
4789  self._processMap = {}
4790  self._processMap["connect"] = Processor.process_connect
4791  self._processMap["krb5_connect"] = Processor.process_krb5_connect
4792  self._processMap["disconnect"] = Processor.process_disconnect
4793  self._processMap["switch_database"] = Processor.process_switch_database
4794  self._processMap["clone_session"] = Processor.process_clone_session
4795  self._processMap["get_server_status"] = Processor.process_get_server_status
4796  self._processMap["get_status"] = Processor.process_get_status
4797  self._processMap["get_hardware_info"] = Processor.process_get_hardware_info
4798  self._processMap["get_tables"] = Processor.process_get_tables
4799  self._processMap["get_tables_for_database"] = Processor.process_get_tables_for_database
4800  self._processMap["get_physical_tables"] = Processor.process_get_physical_tables
4801  self._processMap["get_views"] = Processor.process_get_views
4802  self._processMap["get_tables_meta"] = Processor.process_get_tables_meta
4803  self._processMap["get_table_details"] = Processor.process_get_table_details
4804  self._processMap["get_table_details_for_database"] = Processor.process_get_table_details_for_database
4805  self._processMap["get_internal_table_details"] = Processor.process_get_internal_table_details
4806  self._processMap["get_internal_table_details_for_database"] = Processor.process_get_internal_table_details_for_database
4807  self._processMap["get_users"] = Processor.process_get_users
4808  self._processMap["get_databases"] = Processor.process_get_databases
4809  self._processMap["get_version"] = Processor.process_get_version
4810  self._processMap["start_heap_profile"] = Processor.process_start_heap_profile
4811  self._processMap["stop_heap_profile"] = Processor.process_stop_heap_profile
4812  self._processMap["get_heap_profile"] = Processor.process_get_heap_profile
4813  self._processMap["get_memory"] = Processor.process_get_memory
4814  self._processMap["clear_cpu_memory"] = Processor.process_clear_cpu_memory
4815  self._processMap["clear_gpu_memory"] = Processor.process_clear_gpu_memory
4816  self._processMap["set_cur_session"] = Processor.process_set_cur_session
4817  self._processMap["invalidate_cur_session"] = Processor.process_invalidate_cur_session
4818  self._processMap["set_table_epoch"] = Processor.process_set_table_epoch
4819  self._processMap["set_table_epoch_by_name"] = Processor.process_set_table_epoch_by_name
4820  self._processMap["get_table_epoch"] = Processor.process_get_table_epoch
4821  self._processMap["get_table_epoch_by_name"] = Processor.process_get_table_epoch_by_name
4822  self._processMap["get_table_epochs"] = Processor.process_get_table_epochs
4823  self._processMap["set_table_epochs"] = Processor.process_set_table_epochs
4824  self._processMap["get_session_info"] = Processor.process_get_session_info
4825  self._processMap["get_queries_info"] = Processor.process_get_queries_info
4826  self._processMap["set_leaf_info"] = Processor.process_set_leaf_info
4827  self._processMap["sql_execute"] = Processor.process_sql_execute
4828  self._processMap["sql_execute_df"] = Processor.process_sql_execute_df
4829  self._processMap["sql_execute_gdf"] = Processor.process_sql_execute_gdf
4830  self._processMap["deallocate_df"] = Processor.process_deallocate_df
4831  self._processMap["interrupt"] = Processor.process_interrupt
4832  self._processMap["sql_validate"] = Processor.process_sql_validate
4833  self._processMap["get_completion_hints"] = Processor.process_get_completion_hints
4834  self._processMap["set_execution_mode"] = Processor.process_set_execution_mode
4835  self._processMap["render_vega"] = Processor.process_render_vega
4836  self._processMap["get_result_row_for_pixel"] = Processor.process_get_result_row_for_pixel
4837  self._processMap["create_custom_expression"] = Processor.process_create_custom_expression
4838  self._processMap["get_custom_expressions"] = Processor.process_get_custom_expressions
4839  self._processMap["update_custom_expression"] = Processor.process_update_custom_expression
4840  self._processMap["delete_custom_expressions"] = Processor.process_delete_custom_expressions
4841  self._processMap["get_dashboard"] = Processor.process_get_dashboard
4842  self._processMap["get_dashboards"] = Processor.process_get_dashboards
4843  self._processMap["create_dashboard"] = Processor.process_create_dashboard
4844  self._processMap["replace_dashboard"] = Processor.process_replace_dashboard
4845  self._processMap["delete_dashboard"] = Processor.process_delete_dashboard
4846  self._processMap["share_dashboards"] = Processor.process_share_dashboards
4847  self._processMap["delete_dashboards"] = Processor.process_delete_dashboards
4848  self._processMap["share_dashboard"] = Processor.process_share_dashboard
4849  self._processMap["unshare_dashboard"] = Processor.process_unshare_dashboard
4850  self._processMap["unshare_dashboards"] = Processor.process_unshare_dashboards
4851  self._processMap["get_dashboard_grantees"] = Processor.process_get_dashboard_grantees
4852  self._processMap["get_link_view"] = Processor.process_get_link_view
4853  self._processMap["create_link"] = Processor.process_create_link
4854  self._processMap["load_table_binary"] = Processor.process_load_table_binary
4855  self._processMap["load_table_binary_columnar"] = Processor.process_load_table_binary_columnar
4856  self._processMap["load_table_binary_arrow"] = Processor.process_load_table_binary_arrow
4857  self._processMap["load_table"] = Processor.process_load_table
4858  self._processMap["detect_column_types"] = Processor.process_detect_column_types
4859  self._processMap["create_table"] = Processor.process_create_table
4860  self._processMap["import_table"] = Processor.process_import_table
4861  self._processMap["import_geo_table"] = Processor.process_import_geo_table
4862  self._processMap["import_table_status"] = Processor.process_import_table_status
4863  self._processMap["get_first_geo_file_in_archive"] = Processor.process_get_first_geo_file_in_archive
4864  self._processMap["get_all_files_in_archive"] = Processor.process_get_all_files_in_archive
4865  self._processMap["get_layers_in_geo_file"] = Processor.process_get_layers_in_geo_file
4866  self._processMap["query_get_outer_fragment_count"] = Processor.process_query_get_outer_fragment_count
4867  self._processMap["check_table_consistency"] = Processor.process_check_table_consistency
4868  self._processMap["start_query"] = Processor.process_start_query
4869  self._processMap["execute_query_step"] = Processor.process_execute_query_step
4870  self._processMap["broadcast_serialized_rows"] = Processor.process_broadcast_serialized_rows
4871  self._processMap["start_render_query"] = Processor.process_start_render_query
4872  self._processMap["execute_next_render_step"] = Processor.process_execute_next_render_step
4873  self._processMap["insert_data"] = Processor.process_insert_data
4874  self._processMap["insert_chunks"] = Processor.process_insert_chunks
4875  self._processMap["checkpoint"] = Processor.process_checkpoint
4876  self._processMap["get_roles"] = Processor.process_get_roles
4877  self._processMap["get_db_objects_for_grantee"] = Processor.process_get_db_objects_for_grantee
4878  self._processMap["get_db_object_privs"] = Processor.process_get_db_object_privs
4879  self._processMap["get_all_roles_for_user"] = Processor.process_get_all_roles_for_user
4880  self._processMap["get_all_effective_roles_for_user"] = Processor.process_get_all_effective_roles_for_user
4881  self._processMap["has_role"] = Processor.process_has_role
4882  self._processMap["has_object_privilege"] = Processor.process_has_object_privilege
4883  self._processMap["set_license_key"] = Processor.process_set_license_key
4884  self._processMap["get_license_claims"] = Processor.process_get_license_claims
4885  self._processMap["get_device_parameters"] = Processor.process_get_device_parameters
4886  self._processMap["register_runtime_extension_functions"] = Processor.process_register_runtime_extension_functions
4887  self._processMap["get_table_function_names"] = Processor.process_get_table_function_names
4888  self._processMap["get_runtime_table_function_names"] = Processor.process_get_runtime_table_function_names
4889  self._processMap["get_table_function_details"] = Processor.process_get_table_function_details
4890  self._processMap["get_function_names"] = Processor.process_get_function_names
4891  self._processMap["get_runtime_function_names"] = Processor.process_get_runtime_function_names
4892  self._processMap["get_function_details"] = Processor.process_get_function_details
4893  self._on_message_begin = None

Member Function Documentation

def heavydb.thrift.Heavy.Processor.on_message_begin (   self,
  func 
)

Definition at line 4894 of file Heavy.py.

References heavydb.thrift.Heavy.Processor._on_message_begin.

4895  def on_message_begin(self, func):
4896  self._on_message_begin = func
def heavydb.thrift.Heavy.Processor.process (   self,
  iprot,
  oprot 
)

Definition at line 4897 of file Heavy.py.

References heavydb.thrift.Heavy.Processor._on_message_begin, and heavydb.thrift.Heavy.Processor._processMap.

4898  def process(self, iprot, oprot):
4899  (name, type, seqid) = iprot.readMessageBegin()
4900  if self._on_message_begin:
4901  self._on_message_begin(name, type, seqid)
4902  if name not in self._processMap:
4903  iprot.skip(TType.STRUCT)
4904  iprot.readMessageEnd()
4905  x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4906  oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4907  x.write(oprot)
4908  oprot.writeMessageEnd()
4909  oprot.trans.flush()
4910  return
4911  else:
4912  self._processMap[name](self, seqid, iprot, oprot)
4913  return True
def heavydb.thrift.Heavy.Processor.process_broadcast_serialized_rows (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6982 of file Heavy.py.

6983  def process_broadcast_serialized_rows(self, seqid, iprot, oprot):
6985  args.read(iprot)
6986  iprot.readMessageEnd()
6988  try:
6989  self._handler.broadcast_serialized_rows(args.serialized_rows, args.row_desc, args.query_id, args.subquery_id, args.is_final_subquery_result)
6990  msg_type = TMessageType.REPLY
6991  except TTransport.TTransportException:
6992  raise
6993  except TDBException as e:
6994  msg_type = TMessageType.REPLY
6995  result.e = e
6996  except TApplicationException as ex:
6997  logging.exception('TApplication exception in handler')
6998  msg_type = TMessageType.EXCEPTION
6999  result = ex
7000  except Exception:
7001  logging.exception('Unexpected exception in handler')
7002  msg_type = TMessageType.EXCEPTION
7003  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7004  oprot.writeMessageBegin("broadcast_serialized_rows", msg_type, seqid)
7005  result.write(oprot)
7006  oprot.writeMessageEnd()
7007  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_check_table_consistency (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6904 of file Heavy.py.

6905  def process_check_table_consistency(self, seqid, iprot, oprot):
6907  args.read(iprot)
6908  iprot.readMessageEnd()
6910  try:
6911  result.success = self._handler.check_table_consistency(args.session, args.table_id)
6912  msg_type = TMessageType.REPLY
6913  except TTransport.TTransportException:
6914  raise
6915  except TDBException as e:
6916  msg_type = TMessageType.REPLY
6917  result.e = e
6918  except TApplicationException as ex:
6919  logging.exception('TApplication exception in handler')
6920  msg_type = TMessageType.EXCEPTION
6921  result = ex
6922  except Exception:
6923  logging.exception('Unexpected exception in handler')
6924  msg_type = TMessageType.EXCEPTION
6925  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6926  oprot.writeMessageBegin("check_table_consistency", msg_type, seqid)
6927  result.write(oprot)
6928  oprot.writeMessageEnd()
6929  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_checkpoint (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7112 of file Heavy.py.

7113  def process_checkpoint(self, seqid, iprot, oprot):
7114  args = checkpoint_args()
7115  args.read(iprot)
7116  iprot.readMessageEnd()
7117  result = checkpoint_result()
7118  try:
7119  self._handler.checkpoint(args.session, args.table_id)
7120  msg_type = TMessageType.REPLY
7121  except TTransport.TTransportException:
7122  raise
7123  except TDBException as e:
7124  msg_type = TMessageType.REPLY
7125  result.e = e
7126  except TApplicationException as ex:
7127  logging.exception('TApplication exception in handler')
7128  msg_type = TMessageType.EXCEPTION
7129  result = ex
7130  except Exception:
7131  logging.exception('Unexpected exception in handler')
7132  msg_type = TMessageType.EXCEPTION
7133  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7134  oprot.writeMessageBegin("checkpoint", msg_type, seqid)
7135  result.write(oprot)
7136  oprot.writeMessageEnd()
7137  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_clear_cpu_memory (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5538 of file Heavy.py.

5539  def process_clear_cpu_memory(self, seqid, iprot, oprot):
5540  args = clear_cpu_memory_args()
5541  args.read(iprot)
5542  iprot.readMessageEnd()
5543  result = clear_cpu_memory_result()
5544  try:
5545  self._handler.clear_cpu_memory(args.session)
5546  msg_type = TMessageType.REPLY
5547  except TTransport.TTransportException:
5548  raise
5549  except TDBException as e:
5550  msg_type = TMessageType.REPLY
5551  result.e = e
5552  except TApplicationException as ex:
5553  logging.exception('TApplication exception in handler')
5554  msg_type = TMessageType.EXCEPTION
5555  result = ex
5556  except Exception:
5557  logging.exception('Unexpected exception in handler')
5558  msg_type = TMessageType.EXCEPTION
5559  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5560  oprot.writeMessageBegin("clear_cpu_memory", msg_type, seqid)
5561  result.write(oprot)
5562  oprot.writeMessageEnd()
5563  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_clear_gpu_memory (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5564 of file Heavy.py.

5565  def process_clear_gpu_memory(self, seqid, iprot, oprot):
5566  args = clear_gpu_memory_args()
5567  args.read(iprot)
5568  iprot.readMessageEnd()
5569  result = clear_gpu_memory_result()
5570  try:
5571  self._handler.clear_gpu_memory(args.session)
5572  msg_type = TMessageType.REPLY
5573  except TTransport.TTransportException:
5574  raise
5575  except TDBException as e:
5576  msg_type = TMessageType.REPLY
5577  result.e = e
5578  except TApplicationException as ex:
5579  logging.exception('TApplication exception in handler')
5580  msg_type = TMessageType.EXCEPTION
5581  result = ex
5582  except Exception:
5583  logging.exception('Unexpected exception in handler')
5584  msg_type = TMessageType.EXCEPTION
5585  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5586  oprot.writeMessageBegin("clear_gpu_memory", msg_type, seqid)
5587  result.write(oprot)
5588  oprot.writeMessageEnd()
5589  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_clone_session (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5018 of file Heavy.py.

5019  def process_clone_session(self, seqid, iprot, oprot):
5020  args = clone_session_args()
5021  args.read(iprot)
5022  iprot.readMessageEnd()
5023  result = clone_session_result()
5024  try:
5025  result.success = self._handler.clone_session(args.session)
5026  msg_type = TMessageType.REPLY
5027  except TTransport.TTransportException:
5028  raise
5029  except TDBException as e:
5030  msg_type = TMessageType.REPLY
5031  result.e = e
5032  except TApplicationException as ex:
5033  logging.exception('TApplication exception in handler')
5034  msg_type = TMessageType.EXCEPTION
5035  result = ex
5036  except Exception:
5037  logging.exception('Unexpected exception in handler')
5038  msg_type = TMessageType.EXCEPTION
5039  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5040  oprot.writeMessageBegin("clone_session", msg_type, seqid)
5041  result.write(oprot)
5042  oprot.writeMessageEnd()
5043  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_connect (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 4914 of file Heavy.py.

4915  def process_connect(self, seqid, iprot, oprot):
4916  args = connect_args()
4917  args.read(iprot)
4918  iprot.readMessageEnd()
4919  result = connect_result()
4920  try:
4921  result.success = self._handler.connect(args.user, args.passwd, args.dbname)
4922  msg_type = TMessageType.REPLY
4923  except TTransport.TTransportException:
4924  raise
4925  except TDBException as e:
4926  msg_type = TMessageType.REPLY
4927  result.e = e
4928  except TApplicationException as ex:
4929  logging.exception('TApplication exception in handler')
4930  msg_type = TMessageType.EXCEPTION
4931  result = ex
4932  except Exception:
4933  logging.exception('Unexpected exception in handler')
4934  msg_type = TMessageType.EXCEPTION
4935  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
4936  oprot.writeMessageBegin("connect", msg_type, seqid)
4937  result.write(oprot)
4938  oprot.writeMessageEnd()
4939  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_create_custom_expression (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6124 of file Heavy.py.

6125  def process_create_custom_expression(self, seqid, iprot, oprot):
6127  args.read(iprot)
6128  iprot.readMessageEnd()
6130  try:
6131  result.success = self._handler.create_custom_expression(args.session, args.custom_expression)
6132  msg_type = TMessageType.REPLY
6133  except TTransport.TTransportException:
6134  raise
6135  except TDBException as e:
6136  msg_type = TMessageType.REPLY
6137  result.e = e
6138  except TApplicationException as ex:
6139  logging.exception('TApplication exception in handler')
6140  msg_type = TMessageType.EXCEPTION
6141  result = ex
6142  except Exception:
6143  logging.exception('Unexpected exception in handler')
6144  msg_type = TMessageType.EXCEPTION
6145  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6146  oprot.writeMessageBegin("create_custom_expression", msg_type, seqid)
6147  result.write(oprot)
6148  oprot.writeMessageEnd()
6149  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_create_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6280 of file Heavy.py.

6281  def process_create_dashboard(self, seqid, iprot, oprot):
6282  args = create_dashboard_args()
6283  args.read(iprot)
6284  iprot.readMessageEnd()
6285  result = create_dashboard_result()
6286  try:
6287  result.success = self._handler.create_dashboard(args.session, args.dashboard_name, args.dashboard_state, args.image_hash, args.dashboard_metadata)
6288  msg_type = TMessageType.REPLY
6289  except TTransport.TTransportException:
6290  raise
6291  except TDBException as e:
6292  msg_type = TMessageType.REPLY
6293  result.e = e
6294  except TApplicationException as ex:
6295  logging.exception('TApplication exception in handler')
6296  msg_type = TMessageType.EXCEPTION
6297  result = ex
6298  except Exception:
6299  logging.exception('Unexpected exception in handler')
6300  msg_type = TMessageType.EXCEPTION
6301  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6302  oprot.writeMessageBegin("create_dashboard", msg_type, seqid)
6303  result.write(oprot)
6304  oprot.writeMessageEnd()
6305  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_create_link (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6540 of file Heavy.py.

6541  def process_create_link(self, seqid, iprot, oprot):
6542  args = create_link_args()
6543  args.read(iprot)
6544  iprot.readMessageEnd()
6545  result = create_link_result()
6546  try:
6547  result.success = self._handler.create_link(args.session, args.view_state, args.view_metadata)
6548  msg_type = TMessageType.REPLY
6549  except TTransport.TTransportException:
6550  raise
6551  except TDBException as e:
6552  msg_type = TMessageType.REPLY
6553  result.e = e
6554  except TApplicationException as ex:
6555  logging.exception('TApplication exception in handler')
6556  msg_type = TMessageType.EXCEPTION
6557  result = ex
6558  except Exception:
6559  logging.exception('Unexpected exception in handler')
6560  msg_type = TMessageType.EXCEPTION
6561  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6562  oprot.writeMessageBegin("create_link", msg_type, seqid)
6563  result.write(oprot)
6564  oprot.writeMessageEnd()
6565  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_create_table (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6696 of file Heavy.py.

6697  def process_create_table(self, seqid, iprot, oprot):
6698  args = create_table_args()
6699  args.read(iprot)
6700  iprot.readMessageEnd()
6701  result = create_table_result()
6702  try:
6703  self._handler.create_table(args.session, args.table_name, args.row_desc, args.create_params)
6704  msg_type = TMessageType.REPLY
6705  except TTransport.TTransportException:
6706  raise
6707  except TDBException as e:
6708  msg_type = TMessageType.REPLY
6709  result.e = e
6710  except TApplicationException as ex:
6711  logging.exception('TApplication exception in handler')
6712  msg_type = TMessageType.EXCEPTION
6713  result = ex
6714  except Exception:
6715  logging.exception('Unexpected exception in handler')
6716  msg_type = TMessageType.EXCEPTION
6717  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6718  oprot.writeMessageBegin("create_table", msg_type, seqid)
6719  result.write(oprot)
6720  oprot.writeMessageEnd()
6721  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_deallocate_df (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5942 of file Heavy.py.

5943  def process_deallocate_df(self, seqid, iprot, oprot):
5944  args = deallocate_df_args()
5945  args.read(iprot)
5946  iprot.readMessageEnd()
5947  result = deallocate_df_result()
5948  try:
5949  self._handler.deallocate_df(args.session, args.df, args.device_type, args.device_id)
5950  msg_type = TMessageType.REPLY
5951  except TTransport.TTransportException:
5952  raise
5953  except TDBException as e:
5954  msg_type = TMessageType.REPLY
5955  result.e = e
5956  except TApplicationException as ex:
5957  logging.exception('TApplication exception in handler')
5958  msg_type = TMessageType.EXCEPTION
5959  result = ex
5960  except Exception:
5961  logging.exception('Unexpected exception in handler')
5962  msg_type = TMessageType.EXCEPTION
5963  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5964  oprot.writeMessageBegin("deallocate_df", msg_type, seqid)
5965  result.write(oprot)
5966  oprot.writeMessageEnd()
5967  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_delete_custom_expressions (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6202 of file Heavy.py.

6203  def process_delete_custom_expressions(self, seqid, iprot, oprot):
6205  args.read(iprot)
6206  iprot.readMessageEnd()
6208  try:
6209  self._handler.delete_custom_expressions(args.session, args.custom_expression_ids, args.do_soft_delete)
6210  msg_type = TMessageType.REPLY
6211  except TTransport.TTransportException:
6212  raise
6213  except TDBException as e:
6214  msg_type = TMessageType.REPLY
6215  result.e = e
6216  except TApplicationException as ex:
6217  logging.exception('TApplication exception in handler')
6218  msg_type = TMessageType.EXCEPTION
6219  result = ex
6220  except Exception:
6221  logging.exception('Unexpected exception in handler')
6222  msg_type = TMessageType.EXCEPTION
6223  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6224  oprot.writeMessageBegin("delete_custom_expressions", msg_type, seqid)
6225  result.write(oprot)
6226  oprot.writeMessageEnd()
6227  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_delete_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6332 of file Heavy.py.

6333  def process_delete_dashboard(self, seqid, iprot, oprot):
6334  args = delete_dashboard_args()
6335  args.read(iprot)
6336  iprot.readMessageEnd()
6337  result = delete_dashboard_result()
6338  try:
6339  self._handler.delete_dashboard(args.session, args.dashboard_id)
6340  msg_type = TMessageType.REPLY
6341  except TTransport.TTransportException:
6342  raise
6343  except TDBException as e:
6344  msg_type = TMessageType.REPLY
6345  result.e = e
6346  except TApplicationException as ex:
6347  logging.exception('TApplication exception in handler')
6348  msg_type = TMessageType.EXCEPTION
6349  result = ex
6350  except Exception:
6351  logging.exception('Unexpected exception in handler')
6352  msg_type = TMessageType.EXCEPTION
6353  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6354  oprot.writeMessageBegin("delete_dashboard", msg_type, seqid)
6355  result.write(oprot)
6356  oprot.writeMessageEnd()
6357  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_delete_dashboards (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6384 of file Heavy.py.

6385  def process_delete_dashboards(self, seqid, iprot, oprot):
6386  args = delete_dashboards_args()
6387  args.read(iprot)
6388  iprot.readMessageEnd()
6389  result = delete_dashboards_result()
6390  try:
6391  self._handler.delete_dashboards(args.session, args.dashboard_ids)
6392  msg_type = TMessageType.REPLY
6393  except TTransport.TTransportException:
6394  raise
6395  except TDBException as e:
6396  msg_type = TMessageType.REPLY
6397  result.e = e
6398  except TApplicationException as ex:
6399  logging.exception('TApplication exception in handler')
6400  msg_type = TMessageType.EXCEPTION
6401  result = ex
6402  except Exception:
6403  logging.exception('Unexpected exception in handler')
6404  msg_type = TMessageType.EXCEPTION
6405  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6406  oprot.writeMessageBegin("delete_dashboards", msg_type, seqid)
6407  result.write(oprot)
6408  oprot.writeMessageEnd()
6409  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_detect_column_types (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6670 of file Heavy.py.

6671  def process_detect_column_types(self, seqid, iprot, oprot):
6672  args = detect_column_types_args()
6673  args.read(iprot)
6674  iprot.readMessageEnd()
6675  result = detect_column_types_result()
6676  try:
6677  result.success = self._handler.detect_column_types(args.session, args.file_name, args.copy_params)
6678  msg_type = TMessageType.REPLY
6679  except TTransport.TTransportException:
6680  raise
6681  except TDBException as e:
6682  msg_type = TMessageType.REPLY
6683  result.e = e
6684  except TApplicationException as ex:
6685  logging.exception('TApplication exception in handler')
6686  msg_type = TMessageType.EXCEPTION
6687  result = ex
6688  except Exception:
6689  logging.exception('Unexpected exception in handler')
6690  msg_type = TMessageType.EXCEPTION
6691  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6692  oprot.writeMessageBegin("detect_column_types", msg_type, seqid)
6693  result.write(oprot)
6694  oprot.writeMessageEnd()
6695  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_disconnect (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 4966 of file Heavy.py.

4967  def process_disconnect(self, seqid, iprot, oprot):
4968  args = disconnect_args()
4969  args.read(iprot)
4970  iprot.readMessageEnd()
4971  result = disconnect_result()
4972  try:
4973  self._handler.disconnect(args.session)
4974  msg_type = TMessageType.REPLY
4975  except TTransport.TTransportException:
4976  raise
4977  except TDBException as e:
4978  msg_type = TMessageType.REPLY
4979  result.e = e
4980  except TApplicationException as ex:
4981  logging.exception('TApplication exception in handler')
4982  msg_type = TMessageType.EXCEPTION
4983  result = ex
4984  except Exception:
4985  logging.exception('Unexpected exception in handler')
4986  msg_type = TMessageType.EXCEPTION
4987  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
4988  oprot.writeMessageBegin("disconnect", msg_type, seqid)
4989  result.write(oprot)
4990  oprot.writeMessageEnd()
4991  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_execute_next_render_step (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7034 of file Heavy.py.

7035  def process_execute_next_render_step(self, seqid, iprot, oprot):
7037  args.read(iprot)
7038  iprot.readMessageEnd()
7040  try:
7041  result.success = self._handler.execute_next_render_step(args.pending_render, args.merged_data)
7042  msg_type = TMessageType.REPLY
7043  except TTransport.TTransportException:
7044  raise
7045  except TDBException as e:
7046  msg_type = TMessageType.REPLY
7047  result.e = e
7048  except TApplicationException as ex:
7049  logging.exception('TApplication exception in handler')
7050  msg_type = TMessageType.EXCEPTION
7051  result = ex
7052  except Exception:
7053  logging.exception('Unexpected exception in handler')
7054  msg_type = TMessageType.EXCEPTION
7055  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7056  oprot.writeMessageBegin("execute_next_render_step", msg_type, seqid)
7057  result.write(oprot)
7058  oprot.writeMessageEnd()
7059  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_execute_query_step (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6956 of file Heavy.py.

6957  def process_execute_query_step(self, seqid, iprot, oprot):
6958  args = execute_query_step_args()
6959  args.read(iprot)
6960  iprot.readMessageEnd()
6961  result = execute_query_step_result()
6962  try:
6963  result.success = self._handler.execute_query_step(args.pending_query, args.subquery_id, args.start_time_str)
6964  msg_type = TMessageType.REPLY
6965  except TTransport.TTransportException:
6966  raise
6967  except TDBException as e:
6968  msg_type = TMessageType.REPLY
6969  result.e = e
6970  except TApplicationException as ex:
6971  logging.exception('TApplication exception in handler')
6972  msg_type = TMessageType.EXCEPTION
6973  result = ex
6974  except Exception:
6975  logging.exception('Unexpected exception in handler')
6976  msg_type = TMessageType.EXCEPTION
6977  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6978  oprot.writeMessageBegin("execute_query_step", msg_type, seqid)
6979  result.write(oprot)
6980  oprot.writeMessageEnd()
6981  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_all_effective_roles_for_user (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7242 of file Heavy.py.

7243  def process_get_all_effective_roles_for_user(self, seqid, iprot, oprot):
7245  args.read(iprot)
7246  iprot.readMessageEnd()
7248  try:
7249  result.success = self._handler.get_all_effective_roles_for_user(args.session, args.userName)
7250  msg_type = TMessageType.REPLY
7251  except TTransport.TTransportException:
7252  raise
7253  except TDBException as e:
7254  msg_type = TMessageType.REPLY
7255  result.e = e
7256  except TApplicationException as ex:
7257  logging.exception('TApplication exception in handler')
7258  msg_type = TMessageType.EXCEPTION
7259  result = ex
7260  except Exception:
7261  logging.exception('Unexpected exception in handler')
7262  msg_type = TMessageType.EXCEPTION
7263  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7264  oprot.writeMessageBegin("get_all_effective_roles_for_user", msg_type, seqid)
7265  result.write(oprot)
7266  oprot.writeMessageEnd()
7267  oprot.trans.flush()
def process_get_all_effective_roles_for_user
Definition: Heavy.py:7242
def heavydb.thrift.Heavy.Processor.process_get_all_files_in_archive (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6826 of file Heavy.py.

6827  def process_get_all_files_in_archive(self, seqid, iprot, oprot):
6829  args.read(iprot)
6830  iprot.readMessageEnd()
6832  try:
6833  result.success = self._handler.get_all_files_in_archive(args.session, args.archive_path, args.copy_params)
6834  msg_type = TMessageType.REPLY
6835  except TTransport.TTransportException:
6836  raise
6837  except TDBException as e:
6838  msg_type = TMessageType.REPLY
6839  result.e = e
6840  except TApplicationException as ex:
6841  logging.exception('TApplication exception in handler')
6842  msg_type = TMessageType.EXCEPTION
6843  result = ex
6844  except Exception:
6845  logging.exception('Unexpected exception in handler')
6846  msg_type = TMessageType.EXCEPTION
6847  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6848  oprot.writeMessageBegin("get_all_files_in_archive", msg_type, seqid)
6849  result.write(oprot)
6850  oprot.writeMessageEnd()
6851  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_all_roles_for_user (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7216 of file Heavy.py.

7217  def process_get_all_roles_for_user(self, seqid, iprot, oprot):
7219  args.read(iprot)
7220  iprot.readMessageEnd()
7222  try:
7223  result.success = self._handler.get_all_roles_for_user(args.session, args.userName)
7224  msg_type = TMessageType.REPLY
7225  except TTransport.TTransportException:
7226  raise
7227  except TDBException as e:
7228  msg_type = TMessageType.REPLY
7229  result.e = e
7230  except TApplicationException as ex:
7231  logging.exception('TApplication exception in handler')
7232  msg_type = TMessageType.EXCEPTION
7233  result = ex
7234  except Exception:
7235  logging.exception('Unexpected exception in handler')
7236  msg_type = TMessageType.EXCEPTION
7237  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7238  oprot.writeMessageBegin("get_all_roles_for_user", msg_type, seqid)
7239  result.write(oprot)
7240  oprot.writeMessageEnd()
7241  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_completion_hints (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6020 of file Heavy.py.

6021  def process_get_completion_hints(self, seqid, iprot, oprot):
6022  args = get_completion_hints_args()
6023  args.read(iprot)
6024  iprot.readMessageEnd()
6025  result = get_completion_hints_result()
6026  try:
6027  result.success = self._handler.get_completion_hints(args.session, args.sql, args.cursor)
6028  msg_type = TMessageType.REPLY
6029  except TTransport.TTransportException:
6030  raise
6031  except TDBException as e:
6032  msg_type = TMessageType.REPLY
6033  result.e = e
6034  except TApplicationException as ex:
6035  logging.exception('TApplication exception in handler')
6036  msg_type = TMessageType.EXCEPTION
6037  result = ex
6038  except Exception:
6039  logging.exception('Unexpected exception in handler')
6040  msg_type = TMessageType.EXCEPTION
6041  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6042  oprot.writeMessageBegin("get_completion_hints", msg_type, seqid)
6043  result.write(oprot)
6044  oprot.writeMessageEnd()
6045  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_custom_expressions (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6150 of file Heavy.py.

6151  def process_get_custom_expressions(self, seqid, iprot, oprot):
6153  args.read(iprot)
6154  iprot.readMessageEnd()
6156  try:
6157  result.success = self._handler.get_custom_expressions(args.session)
6158  msg_type = TMessageType.REPLY
6159  except TTransport.TTransportException:
6160  raise
6161  except TDBException as e:
6162  msg_type = TMessageType.REPLY
6163  result.e = e
6164  except TApplicationException as ex:
6165  logging.exception('TApplication exception in handler')
6166  msg_type = TMessageType.EXCEPTION
6167  result = ex
6168  except Exception:
6169  logging.exception('Unexpected exception in handler')
6170  msg_type = TMessageType.EXCEPTION
6171  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6172  oprot.writeMessageBegin("get_custom_expressions", msg_type, seqid)
6173  result.write(oprot)
6174  oprot.writeMessageEnd()
6175  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6228 of file Heavy.py.

6229  def process_get_dashboard(self, seqid, iprot, oprot):
6230  args = get_dashboard_args()
6231  args.read(iprot)
6232  iprot.readMessageEnd()
6233  result = get_dashboard_result()
6234  try:
6235  result.success = self._handler.get_dashboard(args.session, args.dashboard_id)
6236  msg_type = TMessageType.REPLY
6237  except TTransport.TTransportException:
6238  raise
6239  except TDBException as e:
6240  msg_type = TMessageType.REPLY
6241  result.e = e
6242  except TApplicationException as ex:
6243  logging.exception('TApplication exception in handler')
6244  msg_type = TMessageType.EXCEPTION
6245  result = ex
6246  except Exception:
6247  logging.exception('Unexpected exception in handler')
6248  msg_type = TMessageType.EXCEPTION
6249  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6250  oprot.writeMessageBegin("get_dashboard", msg_type, seqid)
6251  result.write(oprot)
6252  oprot.writeMessageEnd()
6253  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_dashboard_grantees (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6488 of file Heavy.py.

6489  def process_get_dashboard_grantees(self, seqid, iprot, oprot):
6491  args.read(iprot)
6492  iprot.readMessageEnd()
6494  try:
6495  result.success = self._handler.get_dashboard_grantees(args.session, args.dashboard_id)
6496  msg_type = TMessageType.REPLY
6497  except TTransport.TTransportException:
6498  raise
6499  except TDBException as e:
6500  msg_type = TMessageType.REPLY
6501  result.e = e
6502  except TApplicationException as ex:
6503  logging.exception('TApplication exception in handler')
6504  msg_type = TMessageType.EXCEPTION
6505  result = ex
6506  except Exception:
6507  logging.exception('Unexpected exception in handler')
6508  msg_type = TMessageType.EXCEPTION
6509  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6510  oprot.writeMessageBegin("get_dashboard_grantees", msg_type, seqid)
6511  result.write(oprot)
6512  oprot.writeMessageEnd()
6513  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_dashboards (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6254 of file Heavy.py.

6255  def process_get_dashboards(self, seqid, iprot, oprot):
6256  args = get_dashboards_args()
6257  args.read(iprot)
6258  iprot.readMessageEnd()
6259  result = get_dashboards_result()
6260  try:
6261  result.success = self._handler.get_dashboards(args.session)
6262  msg_type = TMessageType.REPLY
6263  except TTransport.TTransportException:
6264  raise
6265  except TDBException as e:
6266  msg_type = TMessageType.REPLY
6267  result.e = e
6268  except TApplicationException as ex:
6269  logging.exception('TApplication exception in handler')
6270  msg_type = TMessageType.EXCEPTION
6271  result = ex
6272  except Exception:
6273  logging.exception('Unexpected exception in handler')
6274  msg_type = TMessageType.EXCEPTION
6275  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6276  oprot.writeMessageBegin("get_dashboards", msg_type, seqid)
6277  result.write(oprot)
6278  oprot.writeMessageEnd()
6279  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_databases (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5382 of file Heavy.py.

5383  def process_get_databases(self, seqid, iprot, oprot):
5384  args = get_databases_args()
5385  args.read(iprot)
5386  iprot.readMessageEnd()
5387  result = get_databases_result()
5388  try:
5389  result.success = self._handler.get_databases(args.session)
5390  msg_type = TMessageType.REPLY
5391  except TTransport.TTransportException:
5392  raise
5393  except TDBException as e:
5394  msg_type = TMessageType.REPLY
5395  result.e = e
5396  except TApplicationException as ex:
5397  logging.exception('TApplication exception in handler')
5398  msg_type = TMessageType.EXCEPTION
5399  result = ex
5400  except Exception:
5401  logging.exception('Unexpected exception in handler')
5402  msg_type = TMessageType.EXCEPTION
5403  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5404  oprot.writeMessageBegin("get_databases", msg_type, seqid)
5405  result.write(oprot)
5406  oprot.writeMessageEnd()
5407  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_db_object_privs (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7190 of file Heavy.py.

7191  def process_get_db_object_privs(self, seqid, iprot, oprot):
7192  args = get_db_object_privs_args()
7193  args.read(iprot)
7194  iprot.readMessageEnd()
7195  result = get_db_object_privs_result()
7196  try:
7197  result.success = self._handler.get_db_object_privs(args.session, args.objectName, args.type)
7198  msg_type = TMessageType.REPLY
7199  except TTransport.TTransportException:
7200  raise
7201  except TDBException as e:
7202  msg_type = TMessageType.REPLY
7203  result.e = e
7204  except TApplicationException as ex:
7205  logging.exception('TApplication exception in handler')
7206  msg_type = TMessageType.EXCEPTION
7207  result = ex
7208  except Exception:
7209  logging.exception('Unexpected exception in handler')
7210  msg_type = TMessageType.EXCEPTION
7211  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7212  oprot.writeMessageBegin("get_db_object_privs", msg_type, seqid)
7213  result.write(oprot)
7214  oprot.writeMessageEnd()
7215  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_db_objects_for_grantee (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7164 of file Heavy.py.

7165  def process_get_db_objects_for_grantee(self, seqid, iprot, oprot):
7167  args.read(iprot)
7168  iprot.readMessageEnd()
7170  try:
7171  result.success = self._handler.get_db_objects_for_grantee(args.session, args.roleName)
7172  msg_type = TMessageType.REPLY
7173  except TTransport.TTransportException:
7174  raise
7175  except TDBException as e:
7176  msg_type = TMessageType.REPLY
7177  result.e = e
7178  except TApplicationException as ex:
7179  logging.exception('TApplication exception in handler')
7180  msg_type = TMessageType.EXCEPTION
7181  result = ex
7182  except Exception:
7183  logging.exception('Unexpected exception in handler')
7184  msg_type = TMessageType.EXCEPTION
7185  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7186  oprot.writeMessageBegin("get_db_objects_for_grantee", msg_type, seqid)
7187  result.write(oprot)
7188  oprot.writeMessageEnd()
7189  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_device_parameters (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7372 of file Heavy.py.

7373  def process_get_device_parameters(self, seqid, iprot, oprot):
7375  args.read(iprot)
7376  iprot.readMessageEnd()
7377  result = get_device_parameters_result()
7378  try:
7379  result.success = self._handler.get_device_parameters(args.session)
7380  msg_type = TMessageType.REPLY
7381  except TTransport.TTransportException:
7382  raise
7383  except TDBException as e:
7384  msg_type = TMessageType.REPLY
7385  result.e = e
7386  except TApplicationException as ex:
7387  logging.exception('TApplication exception in handler')
7388  msg_type = TMessageType.EXCEPTION
7389  result = ex
7390  except Exception:
7391  logging.exception('Unexpected exception in handler')
7392  msg_type = TMessageType.EXCEPTION
7393  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7394  oprot.writeMessageBegin("get_device_parameters", msg_type, seqid)
7395  result.write(oprot)
7396  oprot.writeMessageEnd()
7397  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_first_geo_file_in_archive (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6800 of file Heavy.py.

6801  def process_get_first_geo_file_in_archive(self, seqid, iprot, oprot):
6803  args.read(iprot)
6804  iprot.readMessageEnd()
6806  try:
6807  result.success = self._handler.get_first_geo_file_in_archive(args.session, args.archive_path, args.copy_params)
6808  msg_type = TMessageType.REPLY
6809  except TTransport.TTransportException:
6810  raise
6811  except TDBException as e:
6812  msg_type = TMessageType.REPLY
6813  result.e = e
6814  except TApplicationException as ex:
6815  logging.exception('TApplication exception in handler')
6816  msg_type = TMessageType.EXCEPTION
6817  result = ex
6818  except Exception:
6819  logging.exception('Unexpected exception in handler')
6820  msg_type = TMessageType.EXCEPTION
6821  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6822  oprot.writeMessageBegin("get_first_geo_file_in_archive", msg_type, seqid)
6823  result.write(oprot)
6824  oprot.writeMessageEnd()
6825  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_function_details (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7554 of file Heavy.py.

7555  def process_get_function_details(self, seqid, iprot, oprot):
7556  args = get_function_details_args()
7557  args.read(iprot)
7558  iprot.readMessageEnd()
7559  result = get_function_details_result()
7560  try:
7561  result.success = self._handler.get_function_details(args.session, args.udf_names)
7562  msg_type = TMessageType.REPLY
7563  except TTransport.TTransportException:
7564  raise
7565  except TDBException as e:
7566  msg_type = TMessageType.REPLY
7567  result.e = e
7568  except TApplicationException as ex:
7569  logging.exception('TApplication exception in handler')
7570  msg_type = TMessageType.EXCEPTION
7571  result = ex
7572  except Exception:
7573  logging.exception('Unexpected exception in handler')
7574  msg_type = TMessageType.EXCEPTION
7575  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7576  oprot.writeMessageBegin("get_function_details", msg_type, seqid)
7577  result.write(oprot)
7578  oprot.writeMessageEnd()
7579  oprot.trans.flush()
7580 
7581 # HELPER FUNCTIONS AND STRUCTURES
7582 
def heavydb.thrift.Heavy.Processor.process_get_function_names (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7502 of file Heavy.py.

7503  def process_get_function_names(self, seqid, iprot, oprot):
7504  args = get_function_names_args()
7505  args.read(iprot)
7506  iprot.readMessageEnd()
7507  result = get_function_names_result()
7508  try:
7509  result.success = self._handler.get_function_names(args.session)
7510  msg_type = TMessageType.REPLY
7511  except TTransport.TTransportException:
7512  raise
7513  except TDBException as e:
7514  msg_type = TMessageType.REPLY
7515  result.e = e
7516  except TApplicationException as ex:
7517  logging.exception('TApplication exception in handler')
7518  msg_type = TMessageType.EXCEPTION
7519  result = ex
7520  except Exception:
7521  logging.exception('Unexpected exception in handler')
7522  msg_type = TMessageType.EXCEPTION
7523  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7524  oprot.writeMessageBegin("get_function_names", msg_type, seqid)
7525  result.write(oprot)
7526  oprot.writeMessageEnd()
7527  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_hardware_info (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5096 of file Heavy.py.

5097  def process_get_hardware_info(self, seqid, iprot, oprot):
5098  args = get_hardware_info_args()
5099  args.read(iprot)
5100  iprot.readMessageEnd()
5101  result = get_hardware_info_result()
5102  try:
5103  result.success = self._handler.get_hardware_info(args.session)
5104  msg_type = TMessageType.REPLY
5105  except TTransport.TTransportException:
5106  raise
5107  except TDBException as e:
5108  msg_type = TMessageType.REPLY
5109  result.e = e
5110  except TApplicationException as ex:
5111  logging.exception('TApplication exception in handler')
5112  msg_type = TMessageType.EXCEPTION
5113  result = ex
5114  except Exception:
5115  logging.exception('Unexpected exception in handler')
5116  msg_type = TMessageType.EXCEPTION
5117  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5118  oprot.writeMessageBegin("get_hardware_info", msg_type, seqid)
5119  result.write(oprot)
5120  oprot.writeMessageEnd()
5121  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_heap_profile (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5486 of file Heavy.py.

5487  def process_get_heap_profile(self, seqid, iprot, oprot):
5488  args = get_heap_profile_args()
5489  args.read(iprot)
5490  iprot.readMessageEnd()
5491  result = get_heap_profile_result()
5492  try:
5493  result.success = self._handler.get_heap_profile(args.session)
5494  msg_type = TMessageType.REPLY
5495  except TTransport.TTransportException:
5496  raise
5497  except TDBException as e:
5498  msg_type = TMessageType.REPLY
5499  result.e = e
5500  except TApplicationException as ex:
5501  logging.exception('TApplication exception in handler')
5502  msg_type = TMessageType.EXCEPTION
5503  result = ex
5504  except Exception:
5505  logging.exception('Unexpected exception in handler')
5506  msg_type = TMessageType.EXCEPTION
5507  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5508  oprot.writeMessageBegin("get_heap_profile", msg_type, seqid)
5509  result.write(oprot)
5510  oprot.writeMessageEnd()
5511  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_internal_table_details (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5304 of file Heavy.py.

5305  def process_get_internal_table_details(self, seqid, iprot, oprot):
5307  args.read(iprot)
5308  iprot.readMessageEnd()
5310  try:
5311  result.success = self._handler.get_internal_table_details(args.session, args.table_name, args.include_system_columns)
5312  msg_type = TMessageType.REPLY
5313  except TTransport.TTransportException:
5314  raise
5315  except TDBException as e:
5316  msg_type = TMessageType.REPLY
5317  result.e = e
5318  except TApplicationException as ex:
5319  logging.exception('TApplication exception in handler')
5320  msg_type = TMessageType.EXCEPTION
5321  result = ex
5322  except Exception:
5323  logging.exception('Unexpected exception in handler')
5324  msg_type = TMessageType.EXCEPTION
5325  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5326  oprot.writeMessageBegin("get_internal_table_details", msg_type, seqid)
5327  result.write(oprot)
5328  oprot.writeMessageEnd()
5329  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_internal_table_details_for_database (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5330 of file Heavy.py.

5331  def process_get_internal_table_details_for_database(self, seqid, iprot, oprot):
5333  args.read(iprot)
5334  iprot.readMessageEnd()
5336  try:
5337  result.success = self._handler.get_internal_table_details_for_database(args.session, args.table_name, args.database_name)
5338  msg_type = TMessageType.REPLY
5339  except TTransport.TTransportException:
5340  raise
5341  except TDBException as e:
5342  msg_type = TMessageType.REPLY
5343  result.e = e
5344  except TApplicationException as ex:
5345  logging.exception('TApplication exception in handler')
5346  msg_type = TMessageType.EXCEPTION
5347  result = ex
5348  except Exception:
5349  logging.exception('Unexpected exception in handler')
5350  msg_type = TMessageType.EXCEPTION
5351  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5352  oprot.writeMessageBegin("get_internal_table_details_for_database", msg_type, seqid)
5353  result.write(oprot)
5354  oprot.writeMessageEnd()
5355  oprot.trans.flush()
def process_get_internal_table_details_for_database
Definition: Heavy.py:5330
def heavydb.thrift.Heavy.Processor.process_get_layers_in_geo_file (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6852 of file Heavy.py.

6853  def process_get_layers_in_geo_file(self, seqid, iprot, oprot):
6855  args.read(iprot)
6856  iprot.readMessageEnd()
6858  try:
6859  result.success = self._handler.get_layers_in_geo_file(args.session, args.file_name, args.copy_params)
6860  msg_type = TMessageType.REPLY
6861  except TTransport.TTransportException:
6862  raise
6863  except TDBException as e:
6864  msg_type = TMessageType.REPLY
6865  result.e = e
6866  except TApplicationException as ex:
6867  logging.exception('TApplication exception in handler')
6868  msg_type = TMessageType.EXCEPTION
6869  result = ex
6870  except Exception:
6871  logging.exception('Unexpected exception in handler')
6872  msg_type = TMessageType.EXCEPTION
6873  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6874  oprot.writeMessageBegin("get_layers_in_geo_file", msg_type, seqid)
6875  result.write(oprot)
6876  oprot.writeMessageEnd()
6877  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_license_claims (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7346 of file Heavy.py.

7347  def process_get_license_claims(self, seqid, iprot, oprot):
7348  args = get_license_claims_args()
7349  args.read(iprot)
7350  iprot.readMessageEnd()
7351  result = get_license_claims_result()
7352  try:
7353  result.success = self._handler.get_license_claims(args.session, args.nonce)
7354  msg_type = TMessageType.REPLY
7355  except TTransport.TTransportException:
7356  raise
7357  except TDBException as e:
7358  msg_type = TMessageType.REPLY
7359  result.e = e
7360  except TApplicationException as ex:
7361  logging.exception('TApplication exception in handler')
7362  msg_type = TMessageType.EXCEPTION
7363  result = ex
7364  except Exception:
7365  logging.exception('Unexpected exception in handler')
7366  msg_type = TMessageType.EXCEPTION
7367  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7368  oprot.writeMessageBegin("get_license_claims", msg_type, seqid)
7369  result.write(oprot)
7370  oprot.writeMessageEnd()
7371  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_link_view (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6514 of file Heavy.py.

6515  def process_get_link_view(self, seqid, iprot, oprot):
6516  args = get_link_view_args()
6517  args.read(iprot)
6518  iprot.readMessageEnd()
6519  result = get_link_view_result()
6520  try:
6521  result.success = self._handler.get_link_view(args.session, args.link)
6522  msg_type = TMessageType.REPLY
6523  except TTransport.TTransportException:
6524  raise
6525  except TDBException as e:
6526  msg_type = TMessageType.REPLY
6527  result.e = e
6528  except TApplicationException as ex:
6529  logging.exception('TApplication exception in handler')
6530  msg_type = TMessageType.EXCEPTION
6531  result = ex
6532  except Exception:
6533  logging.exception('Unexpected exception in handler')
6534  msg_type = TMessageType.EXCEPTION
6535  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6536  oprot.writeMessageBegin("get_link_view", msg_type, seqid)
6537  result.write(oprot)
6538  oprot.writeMessageEnd()
6539  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_memory (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5512 of file Heavy.py.

5513  def process_get_memory(self, seqid, iprot, oprot):
5514  args = get_memory_args()
5515  args.read(iprot)
5516  iprot.readMessageEnd()
5517  result = get_memory_result()
5518  try:
5519  result.success = self._handler.get_memory(args.session, args.memory_level)
5520  msg_type = TMessageType.REPLY
5521  except TTransport.TTransportException:
5522  raise
5523  except TDBException as e:
5524  msg_type = TMessageType.REPLY
5525  result.e = e
5526  except TApplicationException as ex:
5527  logging.exception('TApplication exception in handler')
5528  msg_type = TMessageType.EXCEPTION
5529  result = ex
5530  except Exception:
5531  logging.exception('Unexpected exception in handler')
5532  msg_type = TMessageType.EXCEPTION
5533  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5534  oprot.writeMessageBegin("get_memory", msg_type, seqid)
5535  result.write(oprot)
5536  oprot.writeMessageEnd()
5537  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_physical_tables (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5174 of file Heavy.py.

5175  def process_get_physical_tables(self, seqid, iprot, oprot):
5176  args = get_physical_tables_args()
5177  args.read(iprot)
5178  iprot.readMessageEnd()
5179  result = get_physical_tables_result()
5180  try:
5181  result.success = self._handler.get_physical_tables(args.session)
5182  msg_type = TMessageType.REPLY
5183  except TTransport.TTransportException:
5184  raise
5185  except TDBException as e:
5186  msg_type = TMessageType.REPLY
5187  result.e = e
5188  except TApplicationException as ex:
5189  logging.exception('TApplication exception in handler')
5190  msg_type = TMessageType.EXCEPTION
5191  result = ex
5192  except Exception:
5193  logging.exception('Unexpected exception in handler')
5194  msg_type = TMessageType.EXCEPTION
5195  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5196  oprot.writeMessageBegin("get_physical_tables", msg_type, seqid)
5197  result.write(oprot)
5198  oprot.writeMessageEnd()
5199  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_queries_info (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5812 of file Heavy.py.

5813  def process_get_queries_info(self, seqid, iprot, oprot):
5814  args = get_queries_info_args()
5815  args.read(iprot)
5816  iprot.readMessageEnd()
5817  result = get_queries_info_result()
5818  try:
5819  result.success = self._handler.get_queries_info(args.session)
5820  msg_type = TMessageType.REPLY
5821  except TTransport.TTransportException:
5822  raise
5823  except TDBException as e:
5824  msg_type = TMessageType.REPLY
5825  result.e = e
5826  except TApplicationException as ex:
5827  logging.exception('TApplication exception in handler')
5828  msg_type = TMessageType.EXCEPTION
5829  result = ex
5830  except Exception:
5831  logging.exception('Unexpected exception in handler')
5832  msg_type = TMessageType.EXCEPTION
5833  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5834  oprot.writeMessageBegin("get_queries_info", msg_type, seqid)
5835  result.write(oprot)
5836  oprot.writeMessageEnd()
5837  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_result_row_for_pixel (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6098 of file Heavy.py.

6099  def process_get_result_row_for_pixel(self, seqid, iprot, oprot):
6101  args.read(iprot)
6102  iprot.readMessageEnd()
6104  try:
6105  result.success = self._handler.get_result_row_for_pixel(args.session, args.widget_id, args.pixel, args.table_col_names, args.column_format, args.pixelRadius, args.nonce)
6106  msg_type = TMessageType.REPLY
6107  except TTransport.TTransportException:
6108  raise
6109  except TDBException as e:
6110  msg_type = TMessageType.REPLY
6111  result.e = e
6112  except TApplicationException as ex:
6113  logging.exception('TApplication exception in handler')
6114  msg_type = TMessageType.EXCEPTION
6115  result = ex
6116  except Exception:
6117  logging.exception('Unexpected exception in handler')
6118  msg_type = TMessageType.EXCEPTION
6119  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6120  oprot.writeMessageBegin("get_result_row_for_pixel", msg_type, seqid)
6121  result.write(oprot)
6122  oprot.writeMessageEnd()
6123  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_roles (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7138 of file Heavy.py.

7139  def process_get_roles(self, seqid, iprot, oprot):
7140  args = get_roles_args()
7141  args.read(iprot)
7142  iprot.readMessageEnd()
7143  result = get_roles_result()
7144  try:
7145  result.success = self._handler.get_roles(args.session)
7146  msg_type = TMessageType.REPLY
7147  except TTransport.TTransportException:
7148  raise
7149  except TDBException as e:
7150  msg_type = TMessageType.REPLY
7151  result.e = e
7152  except TApplicationException as ex:
7153  logging.exception('TApplication exception in handler')
7154  msg_type = TMessageType.EXCEPTION
7155  result = ex
7156  except Exception:
7157  logging.exception('Unexpected exception in handler')
7158  msg_type = TMessageType.EXCEPTION
7159  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7160  oprot.writeMessageBegin("get_roles", msg_type, seqid)
7161  result.write(oprot)
7162  oprot.writeMessageEnd()
7163  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_runtime_function_names (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7528 of file Heavy.py.

7529  def process_get_runtime_function_names(self, seqid, iprot, oprot):
7531  args.read(iprot)
7532  iprot.readMessageEnd()
7534  try:
7535  result.success = self._handler.get_runtime_function_names(args.session)
7536  msg_type = TMessageType.REPLY
7537  except TTransport.TTransportException:
7538  raise
7539  except TDBException as e:
7540  msg_type = TMessageType.REPLY
7541  result.e = e
7542  except TApplicationException as ex:
7543  logging.exception('TApplication exception in handler')
7544  msg_type = TMessageType.EXCEPTION
7545  result = ex
7546  except Exception:
7547  logging.exception('Unexpected exception in handler')
7548  msg_type = TMessageType.EXCEPTION
7549  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7550  oprot.writeMessageBegin("get_runtime_function_names", msg_type, seqid)
7551  result.write(oprot)
7552  oprot.writeMessageEnd()
7553  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_runtime_table_function_names (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7450 of file Heavy.py.

7451  def process_get_runtime_table_function_names(self, seqid, iprot, oprot):
7453  args.read(iprot)
7454  iprot.readMessageEnd()
7456  try:
7457  result.success = self._handler.get_runtime_table_function_names(args.session)
7458  msg_type = TMessageType.REPLY
7459  except TTransport.TTransportException:
7460  raise
7461  except TDBException as e:
7462  msg_type = TMessageType.REPLY
7463  result.e = e
7464  except TApplicationException as ex:
7465  logging.exception('TApplication exception in handler')
7466  msg_type = TMessageType.EXCEPTION
7467  result = ex
7468  except Exception:
7469  logging.exception('Unexpected exception in handler')
7470  msg_type = TMessageType.EXCEPTION
7471  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7472  oprot.writeMessageBegin("get_runtime_table_function_names", msg_type, seqid)
7473  result.write(oprot)
7474  oprot.writeMessageEnd()
7475  oprot.trans.flush()
def process_get_runtime_table_function_names
Definition: Heavy.py:7450
def heavydb.thrift.Heavy.Processor.process_get_server_status (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5044 of file Heavy.py.

5045  def process_get_server_status(self, seqid, iprot, oprot):
5046  args = get_server_status_args()
5047  args.read(iprot)
5048  iprot.readMessageEnd()
5049  result = get_server_status_result()
5050  try:
5051  result.success = self._handler.get_server_status(args.session)
5052  msg_type = TMessageType.REPLY
5053  except TTransport.TTransportException:
5054  raise
5055  except TDBException as e:
5056  msg_type = TMessageType.REPLY
5057  result.e = e
5058  except TApplicationException as ex:
5059  logging.exception('TApplication exception in handler')
5060  msg_type = TMessageType.EXCEPTION
5061  result = ex
5062  except Exception:
5063  logging.exception('Unexpected exception in handler')
5064  msg_type = TMessageType.EXCEPTION
5065  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5066  oprot.writeMessageBegin("get_server_status", msg_type, seqid)
5067  result.write(oprot)
5068  oprot.writeMessageEnd()
5069  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_session_info (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5786 of file Heavy.py.

5787  def process_get_session_info(self, seqid, iprot, oprot):
5788  args = get_session_info_args()
5789  args.read(iprot)
5790  iprot.readMessageEnd()
5791  result = get_session_info_result()
5792  try:
5793  result.success = self._handler.get_session_info(args.session)
5794  msg_type = TMessageType.REPLY
5795  except TTransport.TTransportException:
5796  raise
5797  except TDBException as e:
5798  msg_type = TMessageType.REPLY
5799  result.e = e
5800  except TApplicationException as ex:
5801  logging.exception('TApplication exception in handler')
5802  msg_type = TMessageType.EXCEPTION
5803  result = ex
5804  except Exception:
5805  logging.exception('Unexpected exception in handler')
5806  msg_type = TMessageType.EXCEPTION
5807  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5808  oprot.writeMessageBegin("get_session_info", msg_type, seqid)
5809  result.write(oprot)
5810  oprot.writeMessageEnd()
5811  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_status (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5070 of file Heavy.py.

5071  def process_get_status(self, seqid, iprot, oprot):
5072  args = get_status_args()
5073  args.read(iprot)
5074  iprot.readMessageEnd()
5075  result = get_status_result()
5076  try:
5077  result.success = self._handler.get_status(args.session)
5078  msg_type = TMessageType.REPLY
5079  except TTransport.TTransportException:
5080  raise
5081  except TDBException as e:
5082  msg_type = TMessageType.REPLY
5083  result.e = e
5084  except TApplicationException as ex:
5085  logging.exception('TApplication exception in handler')
5086  msg_type = TMessageType.EXCEPTION
5087  result = ex
5088  except Exception:
5089  logging.exception('Unexpected exception in handler')
5090  msg_type = TMessageType.EXCEPTION
5091  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5092  oprot.writeMessageBegin("get_status", msg_type, seqid)
5093  result.write(oprot)
5094  oprot.writeMessageEnd()
5095  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_details (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5252 of file Heavy.py.

5253  def process_get_table_details(self, seqid, iprot, oprot):
5254  args = get_table_details_args()
5255  args.read(iprot)
5256  iprot.readMessageEnd()
5257  result = get_table_details_result()
5258  try:
5259  result.success = self._handler.get_table_details(args.session, args.table_name)
5260  msg_type = TMessageType.REPLY
5261  except TTransport.TTransportException:
5262  raise
5263  except TDBException as e:
5264  msg_type = TMessageType.REPLY
5265  result.e = e
5266  except TApplicationException as ex:
5267  logging.exception('TApplication exception in handler')
5268  msg_type = TMessageType.EXCEPTION
5269  result = ex
5270  except Exception:
5271  logging.exception('Unexpected exception in handler')
5272  msg_type = TMessageType.EXCEPTION
5273  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5274  oprot.writeMessageBegin("get_table_details", msg_type, seqid)
5275  result.write(oprot)
5276  oprot.writeMessageEnd()
5277  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_details_for_database (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5278 of file Heavy.py.

5279  def process_get_table_details_for_database(self, seqid, iprot, oprot):
5281  args.read(iprot)
5282  iprot.readMessageEnd()
5284  try:
5285  result.success = self._handler.get_table_details_for_database(args.session, args.table_name, args.database_name)
5286  msg_type = TMessageType.REPLY
5287  except TTransport.TTransportException:
5288  raise
5289  except TDBException as e:
5290  msg_type = TMessageType.REPLY
5291  result.e = e
5292  except TApplicationException as ex:
5293  logging.exception('TApplication exception in handler')
5294  msg_type = TMessageType.EXCEPTION
5295  result = ex
5296  except Exception:
5297  logging.exception('Unexpected exception in handler')
5298  msg_type = TMessageType.EXCEPTION
5299  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5300  oprot.writeMessageBegin("get_table_details_for_database", msg_type, seqid)
5301  result.write(oprot)
5302  oprot.writeMessageEnd()
5303  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_epoch (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5694 of file Heavy.py.

5695  def process_get_table_epoch(self, seqid, iprot, oprot):
5696  args = get_table_epoch_args()
5697  args.read(iprot)
5698  iprot.readMessageEnd()
5699  result = get_table_epoch_result()
5700  try:
5701  result.success = self._handler.get_table_epoch(args.session, args.db_id, args.table_id)
5702  msg_type = TMessageType.REPLY
5703  except TTransport.TTransportException:
5704  raise
5705  except TApplicationException as ex:
5706  logging.exception('TApplication exception in handler')
5707  msg_type = TMessageType.EXCEPTION
5708  result = ex
5709  except Exception:
5710  logging.exception('Unexpected exception in handler')
5711  msg_type = TMessageType.EXCEPTION
5712  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5713  oprot.writeMessageBegin("get_table_epoch", msg_type, seqid)
5714  result.write(oprot)
5715  oprot.writeMessageEnd()
5716  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_epoch_by_name (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5717 of file Heavy.py.

5718  def process_get_table_epoch_by_name(self, seqid, iprot, oprot):
5720  args.read(iprot)
5721  iprot.readMessageEnd()
5723  try:
5724  result.success = self._handler.get_table_epoch_by_name(args.session, args.table_name)
5725  msg_type = TMessageType.REPLY
5726  except TTransport.TTransportException:
5727  raise
5728  except TApplicationException as ex:
5729  logging.exception('TApplication exception in handler')
5730  msg_type = TMessageType.EXCEPTION
5731  result = ex
5732  except Exception:
5733  logging.exception('Unexpected exception in handler')
5734  msg_type = TMessageType.EXCEPTION
5735  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5736  oprot.writeMessageBegin("get_table_epoch_by_name", msg_type, seqid)
5737  result.write(oprot)
5738  oprot.writeMessageEnd()
5739  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_epochs (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5740 of file Heavy.py.

5741  def process_get_table_epochs(self, seqid, iprot, oprot):
5742  args = get_table_epochs_args()
5743  args.read(iprot)
5744  iprot.readMessageEnd()
5745  result = get_table_epochs_result()
5746  try:
5747  result.success = self._handler.get_table_epochs(args.session, args.db_id, args.table_id)
5748  msg_type = TMessageType.REPLY
5749  except TTransport.TTransportException:
5750  raise
5751  except TApplicationException as ex:
5752  logging.exception('TApplication exception in handler')
5753  msg_type = TMessageType.EXCEPTION
5754  result = ex
5755  except Exception:
5756  logging.exception('Unexpected exception in handler')
5757  msg_type = TMessageType.EXCEPTION
5758  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5759  oprot.writeMessageBegin("get_table_epochs", msg_type, seqid)
5760  result.write(oprot)
5761  oprot.writeMessageEnd()
5762  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_function_details (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7476 of file Heavy.py.

7477  def process_get_table_function_details(self, seqid, iprot, oprot):
7479  args.read(iprot)
7480  iprot.readMessageEnd()
7482  try:
7483  result.success = self._handler.get_table_function_details(args.session, args.udtf_names)
7484  msg_type = TMessageType.REPLY
7485  except TTransport.TTransportException:
7486  raise
7487  except TDBException as e:
7488  msg_type = TMessageType.REPLY
7489  result.e = e
7490  except TApplicationException as ex:
7491  logging.exception('TApplication exception in handler')
7492  msg_type = TMessageType.EXCEPTION
7493  result = ex
7494  except Exception:
7495  logging.exception('Unexpected exception in handler')
7496  msg_type = TMessageType.EXCEPTION
7497  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7498  oprot.writeMessageBegin("get_table_function_details", msg_type, seqid)
7499  result.write(oprot)
7500  oprot.writeMessageEnd()
7501  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_function_names (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7424 of file Heavy.py.

7425  def process_get_table_function_names(self, seqid, iprot, oprot):
7427  args.read(iprot)
7428  iprot.readMessageEnd()
7430  try:
7431  result.success = self._handler.get_table_function_names(args.session)
7432  msg_type = TMessageType.REPLY
7433  except TTransport.TTransportException:
7434  raise
7435  except TDBException as e:
7436  msg_type = TMessageType.REPLY
7437  result.e = e
7438  except TApplicationException as ex:
7439  logging.exception('TApplication exception in handler')
7440  msg_type = TMessageType.EXCEPTION
7441  result = ex
7442  except Exception:
7443  logging.exception('Unexpected exception in handler')
7444  msg_type = TMessageType.EXCEPTION
7445  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7446  oprot.writeMessageBegin("get_table_function_names", msg_type, seqid)
7447  result.write(oprot)
7448  oprot.writeMessageEnd()
7449  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_tables (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5122 of file Heavy.py.

5123  def process_get_tables(self, seqid, iprot, oprot):
5124  args = get_tables_args()
5125  args.read(iprot)
5126  iprot.readMessageEnd()
5127  result = get_tables_result()
5128  try:
5129  result.success = self._handler.get_tables(args.session)
5130  msg_type = TMessageType.REPLY
5131  except TTransport.TTransportException:
5132  raise
5133  except TDBException as e:
5134  msg_type = TMessageType.REPLY
5135  result.e = e
5136  except TApplicationException as ex:
5137  logging.exception('TApplication exception in handler')
5138  msg_type = TMessageType.EXCEPTION
5139  result = ex
5140  except Exception:
5141  logging.exception('Unexpected exception in handler')
5142  msg_type = TMessageType.EXCEPTION
5143  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5144  oprot.writeMessageBegin("get_tables", msg_type, seqid)
5145  result.write(oprot)
5146  oprot.writeMessageEnd()
5147  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_tables_for_database (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5148 of file Heavy.py.

5149  def process_get_tables_for_database(self, seqid, iprot, oprot):
5151  args.read(iprot)
5152  iprot.readMessageEnd()
5154  try:
5155  result.success = self._handler.get_tables_for_database(args.session, args.database_name)
5156  msg_type = TMessageType.REPLY
5157  except TTransport.TTransportException:
5158  raise
5159  except TDBException as e:
5160  msg_type = TMessageType.REPLY
5161  result.e = e
5162  except TApplicationException as ex:
5163  logging.exception('TApplication exception in handler')
5164  msg_type = TMessageType.EXCEPTION
5165  result = ex
5166  except Exception:
5167  logging.exception('Unexpected exception in handler')
5168  msg_type = TMessageType.EXCEPTION
5169  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5170  oprot.writeMessageBegin("get_tables_for_database", msg_type, seqid)
5171  result.write(oprot)
5172  oprot.writeMessageEnd()
5173  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_tables_meta (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5226 of file Heavy.py.

5227  def process_get_tables_meta(self, seqid, iprot, oprot):
5228  args = get_tables_meta_args()
5229  args.read(iprot)
5230  iprot.readMessageEnd()
5231  result = get_tables_meta_result()
5232  try:
5233  result.success = self._handler.get_tables_meta(args.session)
5234  msg_type = TMessageType.REPLY
5235  except TTransport.TTransportException:
5236  raise
5237  except TDBException as e:
5238  msg_type = TMessageType.REPLY
5239  result.e = e
5240  except TApplicationException as ex:
5241  logging.exception('TApplication exception in handler')
5242  msg_type = TMessageType.EXCEPTION
5243  result = ex
5244  except Exception:
5245  logging.exception('Unexpected exception in handler')
5246  msg_type = TMessageType.EXCEPTION
5247  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5248  oprot.writeMessageBegin("get_tables_meta", msg_type, seqid)
5249  result.write(oprot)
5250  oprot.writeMessageEnd()
5251  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_users (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5356 of file Heavy.py.

5357  def process_get_users(self, seqid, iprot, oprot):
5358  args = get_users_args()
5359  args.read(iprot)
5360  iprot.readMessageEnd()
5361  result = get_users_result()
5362  try:
5363  result.success = self._handler.get_users(args.session)
5364  msg_type = TMessageType.REPLY
5365  except TTransport.TTransportException:
5366  raise
5367  except TDBException as e:
5368  msg_type = TMessageType.REPLY
5369  result.e = e
5370  except TApplicationException as ex:
5371  logging.exception('TApplication exception in handler')
5372  msg_type = TMessageType.EXCEPTION
5373  result = ex
5374  except Exception:
5375  logging.exception('Unexpected exception in handler')
5376  msg_type = TMessageType.EXCEPTION
5377  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5378  oprot.writeMessageBegin("get_users", msg_type, seqid)
5379  result.write(oprot)
5380  oprot.writeMessageEnd()
5381  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_version (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5408 of file Heavy.py.

5409  def process_get_version(self, seqid, iprot, oprot):
5410  args = get_version_args()
5411  args.read(iprot)
5412  iprot.readMessageEnd()
5413  result = get_version_result()
5414  try:
5415  result.success = self._handler.get_version()
5416  msg_type = TMessageType.REPLY
5417  except TTransport.TTransportException:
5418  raise
5419  except TDBException as e:
5420  msg_type = TMessageType.REPLY
5421  result.e = e
5422  except TApplicationException as ex:
5423  logging.exception('TApplication exception in handler')
5424  msg_type = TMessageType.EXCEPTION
5425  result = ex
5426  except Exception:
5427  logging.exception('Unexpected exception in handler')
5428  msg_type = TMessageType.EXCEPTION
5429  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5430  oprot.writeMessageBegin("get_version", msg_type, seqid)
5431  result.write(oprot)
5432  oprot.writeMessageEnd()
5433  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_views (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5200 of file Heavy.py.

5201  def process_get_views(self, seqid, iprot, oprot):
5202  args = get_views_args()
5203  args.read(iprot)
5204  iprot.readMessageEnd()
5205  result = get_views_result()
5206  try:
5207  result.success = self._handler.get_views(args.session)
5208  msg_type = TMessageType.REPLY
5209  except TTransport.TTransportException:
5210  raise
5211  except TDBException as e:
5212  msg_type = TMessageType.REPLY
5213  result.e = e
5214  except TApplicationException as ex:
5215  logging.exception('TApplication exception in handler')
5216  msg_type = TMessageType.EXCEPTION
5217  result = ex
5218  except Exception:
5219  logging.exception('Unexpected exception in handler')
5220  msg_type = TMessageType.EXCEPTION
5221  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5222  oprot.writeMessageBegin("get_views", msg_type, seqid)
5223  result.write(oprot)
5224  oprot.writeMessageEnd()
5225  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_has_object_privilege (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7294 of file Heavy.py.

7295  def process_has_object_privilege(self, seqid, iprot, oprot):
7296  args = has_object_privilege_args()
7297  args.read(iprot)
7298  iprot.readMessageEnd()
7299  result = has_object_privilege_result()
7300  try:
7301  result.success = self._handler.has_object_privilege(args.session, args.granteeName, args.ObjectName, args.objectType, args.permissions)
7302  msg_type = TMessageType.REPLY
7303  except TTransport.TTransportException:
7304  raise
7305  except TDBException as e:
7306  msg_type = TMessageType.REPLY
7307  result.e = e
7308  except TApplicationException as ex:
7309  logging.exception('TApplication exception in handler')
7310  msg_type = TMessageType.EXCEPTION
7311  result = ex
7312  except Exception:
7313  logging.exception('Unexpected exception in handler')
7314  msg_type = TMessageType.EXCEPTION
7315  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7316  oprot.writeMessageBegin("has_object_privilege", msg_type, seqid)
7317  result.write(oprot)
7318  oprot.writeMessageEnd()
7319  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_has_role (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7268 of file Heavy.py.

7269  def process_has_role(self, seqid, iprot, oprot):
7270  args = has_role_args()
7271  args.read(iprot)
7272  iprot.readMessageEnd()
7273  result = has_role_result()
7274  try:
7275  result.success = self._handler.has_role(args.session, args.granteeName, args.roleName)
7276  msg_type = TMessageType.REPLY
7277  except TTransport.TTransportException:
7278  raise
7279  except TDBException as e:
7280  msg_type = TMessageType.REPLY
7281  result.e = e
7282  except TApplicationException as ex:
7283  logging.exception('TApplication exception in handler')
7284  msg_type = TMessageType.EXCEPTION
7285  result = ex
7286  except Exception:
7287  logging.exception('Unexpected exception in handler')
7288  msg_type = TMessageType.EXCEPTION
7289  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7290  oprot.writeMessageBegin("has_role", msg_type, seqid)
7291  result.write(oprot)
7292  oprot.writeMessageEnd()
7293  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_import_geo_table (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6748 of file Heavy.py.

6749  def process_import_geo_table(self, seqid, iprot, oprot):
6750  args = import_geo_table_args()
6751  args.read(iprot)
6752  iprot.readMessageEnd()
6753  result = import_geo_table_result()
6754  try:
6755  self._handler.import_geo_table(args.session, args.table_name, args.file_name, args.copy_params, args.row_desc, args.create_params)
6756  msg_type = TMessageType.REPLY
6757  except TTransport.TTransportException:
6758  raise
6759  except TDBException as e:
6760  msg_type = TMessageType.REPLY
6761  result.e = e
6762  except TApplicationException as ex:
6763  logging.exception('TApplication exception in handler')
6764  msg_type = TMessageType.EXCEPTION
6765  result = ex
6766  except Exception:
6767  logging.exception('Unexpected exception in handler')
6768  msg_type = TMessageType.EXCEPTION
6769  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6770  oprot.writeMessageBegin("import_geo_table", msg_type, seqid)
6771  result.write(oprot)
6772  oprot.writeMessageEnd()
6773  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_import_table (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6722 of file Heavy.py.

6723  def process_import_table(self, seqid, iprot, oprot):
6724  args = import_table_args()
6725  args.read(iprot)
6726  iprot.readMessageEnd()
6727  result = import_table_result()
6728  try:
6729  self._handler.import_table(args.session, args.table_name, args.file_name, args.copy_params)
6730  msg_type = TMessageType.REPLY
6731  except TTransport.TTransportException:
6732  raise
6733  except TDBException as e:
6734  msg_type = TMessageType.REPLY
6735  result.e = e
6736  except TApplicationException as ex:
6737  logging.exception('TApplication exception in handler')
6738  msg_type = TMessageType.EXCEPTION
6739  result = ex
6740  except Exception:
6741  logging.exception('Unexpected exception in handler')
6742  msg_type = TMessageType.EXCEPTION
6743  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6744  oprot.writeMessageBegin("import_table", msg_type, seqid)
6745  result.write(oprot)
6746  oprot.writeMessageEnd()
6747  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_import_table_status (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6774 of file Heavy.py.

6775  def process_import_table_status(self, seqid, iprot, oprot):
6776  args = import_table_status_args()
6777  args.read(iprot)
6778  iprot.readMessageEnd()
6779  result = import_table_status_result()
6780  try:
6781  result.success = self._handler.import_table_status(args.session, args.import_id)
6782  msg_type = TMessageType.REPLY
6783  except TTransport.TTransportException:
6784  raise
6785  except TDBException as e:
6786  msg_type = TMessageType.REPLY
6787  result.e = e
6788  except TApplicationException as ex:
6789  logging.exception('TApplication exception in handler')
6790  msg_type = TMessageType.EXCEPTION
6791  result = ex
6792  except Exception:
6793  logging.exception('Unexpected exception in handler')
6794  msg_type = TMessageType.EXCEPTION
6795  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6796  oprot.writeMessageBegin("import_table_status", msg_type, seqid)
6797  result.write(oprot)
6798  oprot.writeMessageEnd()
6799  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_insert_chunks (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7086 of file Heavy.py.

7087  def process_insert_chunks(self, seqid, iprot, oprot):
7088  args = insert_chunks_args()
7089  args.read(iprot)
7090  iprot.readMessageEnd()
7091  result = insert_chunks_result()
7092  try:
7093  self._handler.insert_chunks(args.session, args.insert_chunks)
7094  msg_type = TMessageType.REPLY
7095  except TTransport.TTransportException:
7096  raise
7097  except TDBException as e:
7098  msg_type = TMessageType.REPLY
7099  result.e = e
7100  except TApplicationException as ex:
7101  logging.exception('TApplication exception in handler')
7102  msg_type = TMessageType.EXCEPTION
7103  result = ex
7104  except Exception:
7105  logging.exception('Unexpected exception in handler')
7106  msg_type = TMessageType.EXCEPTION
7107  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7108  oprot.writeMessageBegin("insert_chunks", msg_type, seqid)
7109  result.write(oprot)
7110  oprot.writeMessageEnd()
7111  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_insert_data (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7060 of file Heavy.py.

7061  def process_insert_data(self, seqid, iprot, oprot):
7062  args = insert_data_args()
7063  args.read(iprot)
7064  iprot.readMessageEnd()
7065  result = insert_data_result()
7066  try:
7067  self._handler.insert_data(args.session, args.insert_data)
7068  msg_type = TMessageType.REPLY
7069  except TTransport.TTransportException:
7070  raise
7071  except TDBException as e:
7072  msg_type = TMessageType.REPLY
7073  result.e = e
7074  except TApplicationException as ex:
7075  logging.exception('TApplication exception in handler')
7076  msg_type = TMessageType.EXCEPTION
7077  result = ex
7078  except Exception:
7079  logging.exception('Unexpected exception in handler')
7080  msg_type = TMessageType.EXCEPTION
7081  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7082  oprot.writeMessageBegin("insert_data", msg_type, seqid)
7083  result.write(oprot)
7084  oprot.writeMessageEnd()
7085  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_interrupt (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5968 of file Heavy.py.

5969  def process_interrupt(self, seqid, iprot, oprot):
5970  args = interrupt_args()
5971  args.read(iprot)
5972  iprot.readMessageEnd()
5973  result = interrupt_result()
5974  try:
5975  self._handler.interrupt(args.query_session, args.interrupt_session)
5976  msg_type = TMessageType.REPLY
5977  except TTransport.TTransportException:
5978  raise
5979  except TDBException as e:
5980  msg_type = TMessageType.REPLY
5981  result.e = e
5982  except TApplicationException as ex:
5983  logging.exception('TApplication exception in handler')
5984  msg_type = TMessageType.EXCEPTION
5985  result = ex
5986  except Exception:
5987  logging.exception('Unexpected exception in handler')
5988  msg_type = TMessageType.EXCEPTION
5989  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5990  oprot.writeMessageBegin("interrupt", msg_type, seqid)
5991  result.write(oprot)
5992  oprot.writeMessageEnd()
5993  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_invalidate_cur_session (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5616 of file Heavy.py.

5617  def process_invalidate_cur_session(self, seqid, iprot, oprot):
5619  args.read(iprot)
5620  iprot.readMessageEnd()
5622  try:
5623  self._handler.invalidate_cur_session(args.parent_session, args.leaf_session, args.start_time_str, args.label, args.for_running_query_kernel)
5624  msg_type = TMessageType.REPLY
5625  except TTransport.TTransportException:
5626  raise
5627  except TDBException as e:
5628  msg_type = TMessageType.REPLY
5629  result.e = e
5630  except TApplicationException as ex:
5631  logging.exception('TApplication exception in handler')
5632  msg_type = TMessageType.EXCEPTION
5633  result = ex
5634  except Exception:
5635  logging.exception('Unexpected exception in handler')
5636  msg_type = TMessageType.EXCEPTION
5637  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5638  oprot.writeMessageBegin("invalidate_cur_session", msg_type, seqid)
5639  result.write(oprot)
5640  oprot.writeMessageEnd()
5641  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_krb5_connect (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 4940 of file Heavy.py.

4941  def process_krb5_connect(self, seqid, iprot, oprot):
4942  args = krb5_connect_args()
4943  args.read(iprot)
4944  iprot.readMessageEnd()
4945  result = krb5_connect_result()
4946  try:
4947  result.success = self._handler.krb5_connect(args.inputToken, args.dbname)
4948  msg_type = TMessageType.REPLY
4949  except TTransport.TTransportException:
4950  raise
4951  except TDBException as e:
4952  msg_type = TMessageType.REPLY
4953  result.e = e
4954  except TApplicationException as ex:
4955  logging.exception('TApplication exception in handler')
4956  msg_type = TMessageType.EXCEPTION
4957  result = ex
4958  except Exception:
4959  logging.exception('Unexpected exception in handler')
4960  msg_type = TMessageType.EXCEPTION
4961  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
4962  oprot.writeMessageBegin("krb5_connect", msg_type, seqid)
4963  result.write(oprot)
4964  oprot.writeMessageEnd()
4965  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_load_table (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6644 of file Heavy.py.

6645  def process_load_table(self, seqid, iprot, oprot):
6646  args = load_table_args()
6647  args.read(iprot)
6648  iprot.readMessageEnd()
6649  result = load_table_result()
6650  try:
6651  self._handler.load_table(args.session, args.table_name, args.rows, args.column_names)
6652  msg_type = TMessageType.REPLY
6653  except TTransport.TTransportException:
6654  raise
6655  except TDBException as e:
6656  msg_type = TMessageType.REPLY
6657  result.e = e
6658  except TApplicationException as ex:
6659  logging.exception('TApplication exception in handler')
6660  msg_type = TMessageType.EXCEPTION
6661  result = ex
6662  except Exception:
6663  logging.exception('Unexpected exception in handler')
6664  msg_type = TMessageType.EXCEPTION
6665  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6666  oprot.writeMessageBegin("load_table", msg_type, seqid)
6667  result.write(oprot)
6668  oprot.writeMessageEnd()
6669  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_load_table_binary (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6566 of file Heavy.py.

6567  def process_load_table_binary(self, seqid, iprot, oprot):
6568  args = load_table_binary_args()
6569  args.read(iprot)
6570  iprot.readMessageEnd()
6571  result = load_table_binary_result()
6572  try:
6573  self._handler.load_table_binary(args.session, args.table_name, args.rows, args.column_names)
6574  msg_type = TMessageType.REPLY
6575  except TTransport.TTransportException:
6576  raise
6577  except TDBException as e:
6578  msg_type = TMessageType.REPLY
6579  result.e = e
6580  except TApplicationException as ex:
6581  logging.exception('TApplication exception in handler')
6582  msg_type = TMessageType.EXCEPTION
6583  result = ex
6584  except Exception:
6585  logging.exception('Unexpected exception in handler')
6586  msg_type = TMessageType.EXCEPTION
6587  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6588  oprot.writeMessageBegin("load_table_binary", msg_type, seqid)
6589  result.write(oprot)
6590  oprot.writeMessageEnd()
6591  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_load_table_binary_arrow (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6618 of file Heavy.py.

6619  def process_load_table_binary_arrow(self, seqid, iprot, oprot):
6621  args.read(iprot)
6622  iprot.readMessageEnd()
6624  try:
6625  self._handler.load_table_binary_arrow(args.session, args.table_name, args.arrow_stream, args.use_column_names)
6626  msg_type = TMessageType.REPLY
6627  except TTransport.TTransportException:
6628  raise
6629  except TDBException as e:
6630  msg_type = TMessageType.REPLY
6631  result.e = e
6632  except TApplicationException as ex:
6633  logging.exception('TApplication exception in handler')
6634  msg_type = TMessageType.EXCEPTION
6635  result = ex
6636  except Exception:
6637  logging.exception('Unexpected exception in handler')
6638  msg_type = TMessageType.EXCEPTION
6639  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6640  oprot.writeMessageBegin("load_table_binary_arrow", msg_type, seqid)
6641  result.write(oprot)
6642  oprot.writeMessageEnd()
6643  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_load_table_binary_columnar (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6592 of file Heavy.py.

6593  def process_load_table_binary_columnar(self, seqid, iprot, oprot):
6595  args.read(iprot)
6596  iprot.readMessageEnd()
6598  try:
6599  self._handler.load_table_binary_columnar(args.session, args.table_name, args.cols, args.column_names)
6600  msg_type = TMessageType.REPLY
6601  except TTransport.TTransportException:
6602  raise
6603  except TDBException as e:
6604  msg_type = TMessageType.REPLY
6605  result.e = e
6606  except TApplicationException as ex:
6607  logging.exception('TApplication exception in handler')
6608  msg_type = TMessageType.EXCEPTION
6609  result = ex
6610  except Exception:
6611  logging.exception('Unexpected exception in handler')
6612  msg_type = TMessageType.EXCEPTION
6613  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6614  oprot.writeMessageBegin("load_table_binary_columnar", msg_type, seqid)
6615  result.write(oprot)
6616  oprot.writeMessageEnd()
6617  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_query_get_outer_fragment_count (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6878 of file Heavy.py.

6879  def process_query_get_outer_fragment_count(self, seqid, iprot, oprot):
6881  args.read(iprot)
6882  iprot.readMessageEnd()
6884  try:
6885  result.success = self._handler.query_get_outer_fragment_count(args.session, args.query)
6886  msg_type = TMessageType.REPLY
6887  except TTransport.TTransportException:
6888  raise
6889  except TDBException as e:
6890  msg_type = TMessageType.REPLY
6891  result.e = e
6892  except TApplicationException as ex:
6893  logging.exception('TApplication exception in handler')
6894  msg_type = TMessageType.EXCEPTION
6895  result = ex
6896  except Exception:
6897  logging.exception('Unexpected exception in handler')
6898  msg_type = TMessageType.EXCEPTION
6899  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6900  oprot.writeMessageBegin("query_get_outer_fragment_count", msg_type, seqid)
6901  result.write(oprot)
6902  oprot.writeMessageEnd()
6903  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_register_runtime_extension_functions (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7398 of file Heavy.py.

7399  def process_register_runtime_extension_functions(self, seqid, iprot, oprot):
7401  args.read(iprot)
7402  iprot.readMessageEnd()
7404  try:
7405  self._handler.register_runtime_extension_functions(args.session, args.udfs, args.udtfs, args.device_ir_map)
7406  msg_type = TMessageType.REPLY
7407  except TTransport.TTransportException:
7408  raise
7409  except TDBException as e:
7410  msg_type = TMessageType.REPLY
7411  result.e = e
7412  except TApplicationException as ex:
7413  logging.exception('TApplication exception in handler')
7414  msg_type = TMessageType.EXCEPTION
7415  result = ex
7416  except Exception:
7417  logging.exception('Unexpected exception in handler')
7418  msg_type = TMessageType.EXCEPTION
7419  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7420  oprot.writeMessageBegin("register_runtime_extension_functions", msg_type, seqid)
7421  result.write(oprot)
7422  oprot.writeMessageEnd()
7423  oprot.trans.flush()
def process_register_runtime_extension_functions
Definition: Heavy.py:7398
def heavydb.thrift.Heavy.Processor.process_render_vega (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6072 of file Heavy.py.

6073  def process_render_vega(self, seqid, iprot, oprot):
6074  args = render_vega_args()
6075  args.read(iprot)
6076  iprot.readMessageEnd()
6077  result = render_vega_result()
6078  try:
6079  result.success = self._handler.render_vega(args.session, args.widget_id, args.vega_json, args.compression_level, args.nonce)
6080  msg_type = TMessageType.REPLY
6081  except TTransport.TTransportException:
6082  raise
6083  except TDBException as e:
6084  msg_type = TMessageType.REPLY
6085  result.e = e
6086  except TApplicationException as ex:
6087  logging.exception('TApplication exception in handler')
6088  msg_type = TMessageType.EXCEPTION
6089  result = ex
6090  except Exception:
6091  logging.exception('Unexpected exception in handler')
6092  msg_type = TMessageType.EXCEPTION
6093  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6094  oprot.writeMessageBegin("render_vega", msg_type, seqid)
6095  result.write(oprot)
6096  oprot.writeMessageEnd()
6097  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_replace_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6306 of file Heavy.py.

6307  def process_replace_dashboard(self, seqid, iprot, oprot):
6308  args = replace_dashboard_args()
6309  args.read(iprot)
6310  iprot.readMessageEnd()
6311  result = replace_dashboard_result()
6312  try:
6313  self._handler.replace_dashboard(args.session, args.dashboard_id, args.dashboard_name, args.dashboard_owner, args.dashboard_state, args.image_hash, args.dashboard_metadata)
6314  msg_type = TMessageType.REPLY
6315  except TTransport.TTransportException:
6316  raise
6317  except TDBException as e:
6318  msg_type = TMessageType.REPLY
6319  result.e = e
6320  except TApplicationException as ex:
6321  logging.exception('TApplication exception in handler')
6322  msg_type = TMessageType.EXCEPTION
6323  result = ex
6324  except Exception:
6325  logging.exception('Unexpected exception in handler')
6326  msg_type = TMessageType.EXCEPTION
6327  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6328  oprot.writeMessageBegin("replace_dashboard", msg_type, seqid)
6329  result.write(oprot)
6330  oprot.writeMessageEnd()
6331  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_cur_session (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5590 of file Heavy.py.

5591  def process_set_cur_session(self, seqid, iprot, oprot):
5592  args = set_cur_session_args()
5593  args.read(iprot)
5594  iprot.readMessageEnd()
5595  result = set_cur_session_result()
5596  try:
5597  self._handler.set_cur_session(args.parent_session, args.leaf_session, args.start_time_str, args.label, args.for_running_query_kernel)
5598  msg_type = TMessageType.REPLY
5599  except TTransport.TTransportException:
5600  raise
5601  except TDBException as e:
5602  msg_type = TMessageType.REPLY
5603  result.e = e
5604  except TApplicationException as ex:
5605  logging.exception('TApplication exception in handler')
5606  msg_type = TMessageType.EXCEPTION
5607  result = ex
5608  except Exception:
5609  logging.exception('Unexpected exception in handler')
5610  msg_type = TMessageType.EXCEPTION
5611  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5612  oprot.writeMessageBegin("set_cur_session", msg_type, seqid)
5613  result.write(oprot)
5614  oprot.writeMessageEnd()
5615  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_execution_mode (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6046 of file Heavy.py.

6047  def process_set_execution_mode(self, seqid, iprot, oprot):
6048  args = set_execution_mode_args()
6049  args.read(iprot)
6050  iprot.readMessageEnd()
6051  result = set_execution_mode_result()
6052  try:
6053  self._handler.set_execution_mode(args.session, args.mode)
6054  msg_type = TMessageType.REPLY
6055  except TTransport.TTransportException:
6056  raise
6057  except TDBException as e:
6058  msg_type = TMessageType.REPLY
6059  result.e = e
6060  except TApplicationException as ex:
6061  logging.exception('TApplication exception in handler')
6062  msg_type = TMessageType.EXCEPTION
6063  result = ex
6064  except Exception:
6065  logging.exception('Unexpected exception in handler')
6066  msg_type = TMessageType.EXCEPTION
6067  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6068  oprot.writeMessageBegin("set_execution_mode", msg_type, seqid)
6069  result.write(oprot)
6070  oprot.writeMessageEnd()
6071  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_leaf_info (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5838 of file Heavy.py.

5839  def process_set_leaf_info(self, seqid, iprot, oprot):
5840  args = set_leaf_info_args()
5841  args.read(iprot)
5842  iprot.readMessageEnd()
5843  result = set_leaf_info_result()
5844  try:
5845  self._handler.set_leaf_info(args.session, args.leaf_info)
5846  msg_type = TMessageType.REPLY
5847  except TTransport.TTransportException:
5848  raise
5849  except TDBException as e:
5850  msg_type = TMessageType.REPLY
5851  result.e = e
5852  except TApplicationException as ex:
5853  logging.exception('TApplication exception in handler')
5854  msg_type = TMessageType.EXCEPTION
5855  result = ex
5856  except Exception:
5857  logging.exception('Unexpected exception in handler')
5858  msg_type = TMessageType.EXCEPTION
5859  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5860  oprot.writeMessageBegin("set_leaf_info", msg_type, seqid)
5861  result.write(oprot)
5862  oprot.writeMessageEnd()
5863  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_license_key (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7320 of file Heavy.py.

7321  def process_set_license_key(self, seqid, iprot, oprot):
7322  args = set_license_key_args()
7323  args.read(iprot)
7324  iprot.readMessageEnd()
7325  result = set_license_key_result()
7326  try:
7327  result.success = self._handler.set_license_key(args.session, args.key, args.nonce)
7328  msg_type = TMessageType.REPLY
7329  except TTransport.TTransportException:
7330  raise
7331  except TDBException as e:
7332  msg_type = TMessageType.REPLY
7333  result.e = e
7334  except TApplicationException as ex:
7335  logging.exception('TApplication exception in handler')
7336  msg_type = TMessageType.EXCEPTION
7337  result = ex
7338  except Exception:
7339  logging.exception('Unexpected exception in handler')
7340  msg_type = TMessageType.EXCEPTION
7341  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7342  oprot.writeMessageBegin("set_license_key", msg_type, seqid)
7343  result.write(oprot)
7344  oprot.writeMessageEnd()
7345  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_table_epoch (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5642 of file Heavy.py.

5643  def process_set_table_epoch(self, seqid, iprot, oprot):
5644  args = set_table_epoch_args()
5645  args.read(iprot)
5646  iprot.readMessageEnd()
5647  result = set_table_epoch_result()
5648  try:
5649  self._handler.set_table_epoch(args.session, args.db_id, args.table_id, args.new_epoch)
5650  msg_type = TMessageType.REPLY
5651  except TTransport.TTransportException:
5652  raise
5653  except TDBException as e:
5654  msg_type = TMessageType.REPLY
5655  result.e = e
5656  except TApplicationException as ex:
5657  logging.exception('TApplication exception in handler')
5658  msg_type = TMessageType.EXCEPTION
5659  result = ex
5660  except Exception:
5661  logging.exception('Unexpected exception in handler')
5662  msg_type = TMessageType.EXCEPTION
5663  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5664  oprot.writeMessageBegin("set_table_epoch", msg_type, seqid)
5665  result.write(oprot)
5666  oprot.writeMessageEnd()
5667  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_table_epoch_by_name (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5668 of file Heavy.py.

5669  def process_set_table_epoch_by_name(self, seqid, iprot, oprot):
5671  args.read(iprot)
5672  iprot.readMessageEnd()
5674  try:
5675  self._handler.set_table_epoch_by_name(args.session, args.table_name, args.new_epoch)
5676  msg_type = TMessageType.REPLY
5677  except TTransport.TTransportException:
5678  raise
5679  except TDBException as e:
5680  msg_type = TMessageType.REPLY
5681  result.e = e
5682  except TApplicationException as ex:
5683  logging.exception('TApplication exception in handler')
5684  msg_type = TMessageType.EXCEPTION
5685  result = ex
5686  except Exception:
5687  logging.exception('Unexpected exception in handler')
5688  msg_type = TMessageType.EXCEPTION
5689  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5690  oprot.writeMessageBegin("set_table_epoch_by_name", msg_type, seqid)
5691  result.write(oprot)
5692  oprot.writeMessageEnd()
5693  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_table_epochs (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5763 of file Heavy.py.

5764  def process_set_table_epochs(self, seqid, iprot, oprot):
5765  args = set_table_epochs_args()
5766  args.read(iprot)
5767  iprot.readMessageEnd()
5768  result = set_table_epochs_result()
5769  try:
5770  self._handler.set_table_epochs(args.session, args.db_id, args.table_epochs)
5771  msg_type = TMessageType.REPLY
5772  except TTransport.TTransportException:
5773  raise
5774  except TApplicationException as ex:
5775  logging.exception('TApplication exception in handler')
5776  msg_type = TMessageType.EXCEPTION
5777  result = ex
5778  except Exception:
5779  logging.exception('Unexpected exception in handler')
5780  msg_type = TMessageType.EXCEPTION
5781  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5782  oprot.writeMessageBegin("set_table_epochs", msg_type, seqid)
5783  result.write(oprot)
5784  oprot.writeMessageEnd()
5785  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_share_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6410 of file Heavy.py.

6411  def process_share_dashboard(self, seqid, iprot, oprot):
6412  args = share_dashboard_args()
6413  args.read(iprot)
6414  iprot.readMessageEnd()
6415  result = share_dashboard_result()
6416  try:
6417  self._handler.share_dashboard(args.session, args.dashboard_id, args.groups, args.objects, args.permissions, args.grant_role)
6418  msg_type = TMessageType.REPLY
6419  except TTransport.TTransportException:
6420  raise
6421  except TDBException as e:
6422  msg_type = TMessageType.REPLY
6423  result.e = e
6424  except TApplicationException as ex:
6425  logging.exception('TApplication exception in handler')
6426  msg_type = TMessageType.EXCEPTION
6427  result = ex
6428  except Exception:
6429  logging.exception('Unexpected exception in handler')
6430  msg_type = TMessageType.EXCEPTION
6431  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6432  oprot.writeMessageBegin("share_dashboard", msg_type, seqid)
6433  result.write(oprot)
6434  oprot.writeMessageEnd()
6435  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_share_dashboards (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6358 of file Heavy.py.

6359  def process_share_dashboards(self, seqid, iprot, oprot):
6360  args = share_dashboards_args()
6361  args.read(iprot)
6362  iprot.readMessageEnd()
6363  result = share_dashboards_result()
6364  try:
6365  self._handler.share_dashboards(args.session, args.dashboard_ids, args.groups, args.permissions)
6366  msg_type = TMessageType.REPLY
6367  except TTransport.TTransportException:
6368  raise
6369  except TDBException as e:
6370  msg_type = TMessageType.REPLY
6371  result.e = e
6372  except TApplicationException as ex:
6373  logging.exception('TApplication exception in handler')
6374  msg_type = TMessageType.EXCEPTION
6375  result = ex
6376  except Exception:
6377  logging.exception('Unexpected exception in handler')
6378  msg_type = TMessageType.EXCEPTION
6379  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6380  oprot.writeMessageBegin("share_dashboards", msg_type, seqid)
6381  result.write(oprot)
6382  oprot.writeMessageEnd()
6383  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_sql_execute (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5864 of file Heavy.py.

5865  def process_sql_execute(self, seqid, iprot, oprot):
5866  args = sql_execute_args()
5867  args.read(iprot)
5868  iprot.readMessageEnd()
5869  result = sql_execute_result()
5870  try:
5871  result.success = self._handler.sql_execute(args.session, args.query, args.column_format, args.nonce, args.first_n, args.at_most_n)
5872  msg_type = TMessageType.REPLY
5873  except TTransport.TTransportException:
5874  raise
5875  except TDBException as e:
5876  msg_type = TMessageType.REPLY
5877  result.e = e
5878  except TApplicationException as ex:
5879  logging.exception('TApplication exception in handler')
5880  msg_type = TMessageType.EXCEPTION
5881  result = ex
5882  except Exception:
5883  logging.exception('Unexpected exception in handler')
5884  msg_type = TMessageType.EXCEPTION
5885  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5886  oprot.writeMessageBegin("sql_execute", msg_type, seqid)
5887  result.write(oprot)
5888  oprot.writeMessageEnd()
5889  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_sql_execute_df (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5890 of file Heavy.py.

5891  def process_sql_execute_df(self, seqid, iprot, oprot):
5892  args = sql_execute_df_args()
5893  args.read(iprot)
5894  iprot.readMessageEnd()
5895  result = sql_execute_df_result()
5896  try:
5897  result.success = self._handler.sql_execute_df(args.session, args.query, args.device_type, args.device_id, args.first_n, args.transport_method)
5898  msg_type = TMessageType.REPLY
5899  except TTransport.TTransportException:
5900  raise
5901  except TDBException as e:
5902  msg_type = TMessageType.REPLY
5903  result.e = e
5904  except TApplicationException as ex:
5905  logging.exception('TApplication exception in handler')
5906  msg_type = TMessageType.EXCEPTION
5907  result = ex
5908  except Exception:
5909  logging.exception('Unexpected exception in handler')
5910  msg_type = TMessageType.EXCEPTION
5911  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5912  oprot.writeMessageBegin("sql_execute_df", msg_type, seqid)
5913  result.write(oprot)
5914  oprot.writeMessageEnd()
5915  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_sql_execute_gdf (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5916 of file Heavy.py.

5917  def process_sql_execute_gdf(self, seqid, iprot, oprot):
5918  args = sql_execute_gdf_args()
5919  args.read(iprot)
5920  iprot.readMessageEnd()
5921  result = sql_execute_gdf_result()
5922  try:
5923  result.success = self._handler.sql_execute_gdf(args.session, args.query, args.device_id, args.first_n)
5924  msg_type = TMessageType.REPLY
5925  except TTransport.TTransportException:
5926  raise
5927  except TDBException as e:
5928  msg_type = TMessageType.REPLY
5929  result.e = e
5930  except TApplicationException as ex:
5931  logging.exception('TApplication exception in handler')
5932  msg_type = TMessageType.EXCEPTION
5933  result = ex
5934  except Exception:
5935  logging.exception('Unexpected exception in handler')
5936  msg_type = TMessageType.EXCEPTION
5937  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5938  oprot.writeMessageBegin("sql_execute_gdf", msg_type, seqid)
5939  result.write(oprot)
5940  oprot.writeMessageEnd()
5941  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_sql_validate (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5994 of file Heavy.py.

5995  def process_sql_validate(self, seqid, iprot, oprot):
5996  args = sql_validate_args()
5997  args.read(iprot)
5998  iprot.readMessageEnd()
5999  result = sql_validate_result()
6000  try:
6001  result.success = self._handler.sql_validate(args.session, args.query)
6002  msg_type = TMessageType.REPLY
6003  except TTransport.TTransportException:
6004  raise
6005  except TDBException as e:
6006  msg_type = TMessageType.REPLY
6007  result.e = e
6008  except TApplicationException as ex:
6009  logging.exception('TApplication exception in handler')
6010  msg_type = TMessageType.EXCEPTION
6011  result = ex
6012  except Exception:
6013  logging.exception('Unexpected exception in handler')
6014  msg_type = TMessageType.EXCEPTION
6015  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6016  oprot.writeMessageBegin("sql_validate", msg_type, seqid)
6017  result.write(oprot)
6018  oprot.writeMessageEnd()
6019  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_start_heap_profile (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5434 of file Heavy.py.

5435  def process_start_heap_profile(self, seqid, iprot, oprot):
5436  args = start_heap_profile_args()
5437  args.read(iprot)
5438  iprot.readMessageEnd()
5439  result = start_heap_profile_result()
5440  try:
5441  self._handler.start_heap_profile(args.session)
5442  msg_type = TMessageType.REPLY
5443  except TTransport.TTransportException:
5444  raise
5445  except TDBException as e:
5446  msg_type = TMessageType.REPLY
5447  result.e = e
5448  except TApplicationException as ex:
5449  logging.exception('TApplication exception in handler')
5450  msg_type = TMessageType.EXCEPTION
5451  result = ex
5452  except Exception:
5453  logging.exception('Unexpected exception in handler')
5454  msg_type = TMessageType.EXCEPTION
5455  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5456  oprot.writeMessageBegin("start_heap_profile", msg_type, seqid)
5457  result.write(oprot)
5458  oprot.writeMessageEnd()
5459  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_start_query (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6930 of file Heavy.py.

6931  def process_start_query(self, seqid, iprot, oprot):
6932  args = start_query_args()
6933  args.read(iprot)
6934  iprot.readMessageEnd()
6935  result = start_query_result()
6936  try:
6937  result.success = self._handler.start_query(args.leaf_session, args.parent_session, args.query_ra, args.start_time_str, args.just_explain, args.outer_fragment_indices)
6938  msg_type = TMessageType.REPLY
6939  except TTransport.TTransportException:
6940  raise
6941  except TDBException as e:
6942  msg_type = TMessageType.REPLY
6943  result.e = e
6944  except TApplicationException as ex:
6945  logging.exception('TApplication exception in handler')
6946  msg_type = TMessageType.EXCEPTION
6947  result = ex
6948  except Exception:
6949  logging.exception('Unexpected exception in handler')
6950  msg_type = TMessageType.EXCEPTION
6951  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6952  oprot.writeMessageBegin("start_query", msg_type, seqid)
6953  result.write(oprot)
6954  oprot.writeMessageEnd()
6955  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_start_render_query (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7008 of file Heavy.py.

7009  def process_start_render_query(self, seqid, iprot, oprot):
7010  args = start_render_query_args()
7011  args.read(iprot)
7012  iprot.readMessageEnd()
7013  result = start_render_query_result()
7014  try:
7015  result.success = self._handler.start_render_query(args.session, args.widget_id, args.node_idx, args.vega_json)
7016  msg_type = TMessageType.REPLY
7017  except TTransport.TTransportException:
7018  raise
7019  except TDBException as e:
7020  msg_type = TMessageType.REPLY
7021  result.e = e
7022  except TApplicationException as ex:
7023  logging.exception('TApplication exception in handler')
7024  msg_type = TMessageType.EXCEPTION
7025  result = ex
7026  except Exception:
7027  logging.exception('Unexpected exception in handler')
7028  msg_type = TMessageType.EXCEPTION
7029  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7030  oprot.writeMessageBegin("start_render_query", msg_type, seqid)
7031  result.write(oprot)
7032  oprot.writeMessageEnd()
7033  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_stop_heap_profile (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5460 of file Heavy.py.

5461  def process_stop_heap_profile(self, seqid, iprot, oprot):
5462  args = stop_heap_profile_args()
5463  args.read(iprot)
5464  iprot.readMessageEnd()
5465  result = stop_heap_profile_result()
5466  try:
5467  self._handler.stop_heap_profile(args.session)
5468  msg_type = TMessageType.REPLY
5469  except TTransport.TTransportException:
5470  raise
5471  except TDBException as e:
5472  msg_type = TMessageType.REPLY
5473  result.e = e
5474  except TApplicationException as ex:
5475  logging.exception('TApplication exception in handler')
5476  msg_type = TMessageType.EXCEPTION
5477  result = ex
5478  except Exception:
5479  logging.exception('Unexpected exception in handler')
5480  msg_type = TMessageType.EXCEPTION
5481  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5482  oprot.writeMessageBegin("stop_heap_profile", msg_type, seqid)
5483  result.write(oprot)
5484  oprot.writeMessageEnd()
5485  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_switch_database (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 4992 of file Heavy.py.

4993  def process_switch_database(self, seqid, iprot, oprot):
4994  args = switch_database_args()
4995  args.read(iprot)
4996  iprot.readMessageEnd()
4997  result = switch_database_result()
4998  try:
4999  self._handler.switch_database(args.session, args.dbname)
5000  msg_type = TMessageType.REPLY
5001  except TTransport.TTransportException:
5002  raise
5003  except TDBException as e:
5004  msg_type = TMessageType.REPLY
5005  result.e = e
5006  except TApplicationException as ex:
5007  logging.exception('TApplication exception in handler')
5008  msg_type = TMessageType.EXCEPTION
5009  result = ex
5010  except Exception:
5011  logging.exception('Unexpected exception in handler')
5012  msg_type = TMessageType.EXCEPTION
5013  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5014  oprot.writeMessageBegin("switch_database", msg_type, seqid)
5015  result.write(oprot)
5016  oprot.writeMessageEnd()
5017  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_unshare_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6436 of file Heavy.py.

6437  def process_unshare_dashboard(self, seqid, iprot, oprot):
6438  args = unshare_dashboard_args()
6439  args.read(iprot)
6440  iprot.readMessageEnd()
6441  result = unshare_dashboard_result()
6442  try:
6443  self._handler.unshare_dashboard(args.session, args.dashboard_id, args.groups, args.objects, args.permissions)
6444  msg_type = TMessageType.REPLY
6445  except TTransport.TTransportException:
6446  raise
6447  except TDBException as e:
6448  msg_type = TMessageType.REPLY
6449  result.e = e
6450  except TApplicationException as ex:
6451  logging.exception('TApplication exception in handler')
6452  msg_type = TMessageType.EXCEPTION
6453  result = ex
6454  except Exception:
6455  logging.exception('Unexpected exception in handler')
6456  msg_type = TMessageType.EXCEPTION
6457  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6458  oprot.writeMessageBegin("unshare_dashboard", msg_type, seqid)
6459  result.write(oprot)
6460  oprot.writeMessageEnd()
6461  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_unshare_dashboards (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6462 of file Heavy.py.

6463  def process_unshare_dashboards(self, seqid, iprot, oprot):
6464  args = unshare_dashboards_args()
6465  args.read(iprot)
6466  iprot.readMessageEnd()
6467  result = unshare_dashboards_result()
6468  try:
6469  self._handler.unshare_dashboards(args.session, args.dashboard_ids, args.groups, args.permissions)
6470  msg_type = TMessageType.REPLY
6471  except TTransport.TTransportException:
6472  raise
6473  except TDBException as e:
6474  msg_type = TMessageType.REPLY
6475  result.e = e
6476  except TApplicationException as ex:
6477  logging.exception('TApplication exception in handler')
6478  msg_type = TMessageType.EXCEPTION
6479  result = ex
6480  except Exception:
6481  logging.exception('Unexpected exception in handler')
6482  msg_type = TMessageType.EXCEPTION
6483  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6484  oprot.writeMessageBegin("unshare_dashboards", msg_type, seqid)
6485  result.write(oprot)
6486  oprot.writeMessageEnd()
6487  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_update_custom_expression (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6176 of file Heavy.py.

6177  def process_update_custom_expression(self, seqid, iprot, oprot):
6179  args.read(iprot)
6180  iprot.readMessageEnd()
6182  try:
6183  self._handler.update_custom_expression(args.session, args.id, args.expression_json)
6184  msg_type = TMessageType.REPLY
6185  except TTransport.TTransportException:
6186  raise
6187  except TDBException as e:
6188  msg_type = TMessageType.REPLY
6189  result.e = e
6190  except TApplicationException as ex:
6191  logging.exception('TApplication exception in handler')
6192  msg_type = TMessageType.EXCEPTION
6193  result = ex
6194  except Exception:
6195  logging.exception('Unexpected exception in handler')
6196  msg_type = TMessageType.EXCEPTION
6197  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6198  oprot.writeMessageBegin("update_custom_expression", msg_type, seqid)
6199  result.write(oprot)
6200  oprot.writeMessageEnd()
6201  oprot.trans.flush()

Member Data Documentation

heavydb.thrift.Heavy.Processor._handler
private

Definition at line 4787 of file Heavy.py.

heavydb.thrift.Heavy.Processor._on_message_begin
private

Definition at line 4892 of file Heavy.py.

Referenced by heavydb.thrift.Heavy.Processor.on_message_begin(), and heavydb.thrift.Heavy.Processor.process().

heavydb.thrift.Heavy.Processor._processMap
private

Definition at line 4788 of file Heavy.py.

Referenced by heavydb.thrift.Heavy.Processor.process().


The documentation for this class was generated from the following file: