OmniSciDB  4201147b46
 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_columnar_polys
 
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
 
- 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_columnar_polys
 
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
 

Private Attributes

 _handler
 
 _processMap
 
 _on_message_begin
 

Detailed Description

Definition at line 4708 of file Heavy.py.

Constructor & Destructor Documentation

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

Definition at line 4709 of file Heavy.py.

4710  def __init__(self, handler):
4711  self._handler = handler
4712  self._processMap = {}
4713  self._processMap["connect"] = Processor.process_connect
4714  self._processMap["krb5_connect"] = Processor.process_krb5_connect
4715  self._processMap["disconnect"] = Processor.process_disconnect
4716  self._processMap["switch_database"] = Processor.process_switch_database
4717  self._processMap["clone_session"] = Processor.process_clone_session
4718  self._processMap["get_server_status"] = Processor.process_get_server_status
4719  self._processMap["get_status"] = Processor.process_get_status
4720  self._processMap["get_hardware_info"] = Processor.process_get_hardware_info
4721  self._processMap["get_tables"] = Processor.process_get_tables
4722  self._processMap["get_tables_for_database"] = Processor.process_get_tables_for_database
4723  self._processMap["get_physical_tables"] = Processor.process_get_physical_tables
4724  self._processMap["get_views"] = Processor.process_get_views
4725  self._processMap["get_tables_meta"] = Processor.process_get_tables_meta
4726  self._processMap["get_table_details"] = Processor.process_get_table_details
4727  self._processMap["get_table_details_for_database"] = Processor.process_get_table_details_for_database
4728  self._processMap["get_internal_table_details"] = Processor.process_get_internal_table_details
4729  self._processMap["get_internal_table_details_for_database"] = Processor.process_get_internal_table_details_for_database
4730  self._processMap["get_users"] = Processor.process_get_users
4731  self._processMap["get_databases"] = Processor.process_get_databases
4732  self._processMap["get_version"] = Processor.process_get_version
4733  self._processMap["start_heap_profile"] = Processor.process_start_heap_profile
4734  self._processMap["stop_heap_profile"] = Processor.process_stop_heap_profile
4735  self._processMap["get_heap_profile"] = Processor.process_get_heap_profile
4736  self._processMap["get_memory"] = Processor.process_get_memory
4737  self._processMap["clear_cpu_memory"] = Processor.process_clear_cpu_memory
4738  self._processMap["clear_gpu_memory"] = Processor.process_clear_gpu_memory
4739  self._processMap["set_cur_session"] = Processor.process_set_cur_session
4740  self._processMap["invalidate_cur_session"] = Processor.process_invalidate_cur_session
4741  self._processMap["set_table_epoch"] = Processor.process_set_table_epoch
4742  self._processMap["set_table_epoch_by_name"] = Processor.process_set_table_epoch_by_name
4743  self._processMap["get_table_epoch"] = Processor.process_get_table_epoch
4744  self._processMap["get_table_epoch_by_name"] = Processor.process_get_table_epoch_by_name
4745  self._processMap["get_table_epochs"] = Processor.process_get_table_epochs
4746  self._processMap["set_table_epochs"] = Processor.process_set_table_epochs
4747  self._processMap["get_session_info"] = Processor.process_get_session_info
4748  self._processMap["get_queries_info"] = Processor.process_get_queries_info
4749  self._processMap["set_leaf_info"] = Processor.process_set_leaf_info
4750  self._processMap["sql_execute"] = Processor.process_sql_execute
4751  self._processMap["sql_execute_df"] = Processor.process_sql_execute_df
4752  self._processMap["sql_execute_gdf"] = Processor.process_sql_execute_gdf
4753  self._processMap["deallocate_df"] = Processor.process_deallocate_df
4754  self._processMap["interrupt"] = Processor.process_interrupt
4755  self._processMap["sql_validate"] = Processor.process_sql_validate
4756  self._processMap["get_completion_hints"] = Processor.process_get_completion_hints
4757  self._processMap["set_execution_mode"] = Processor.process_set_execution_mode
4758  self._processMap["render_vega"] = Processor.process_render_vega
4759  self._processMap["get_result_row_for_pixel"] = Processor.process_get_result_row_for_pixel
4760  self._processMap["create_custom_expression"] = Processor.process_create_custom_expression
4761  self._processMap["get_custom_expressions"] = Processor.process_get_custom_expressions
4762  self._processMap["update_custom_expression"] = Processor.process_update_custom_expression
4763  self._processMap["delete_custom_expressions"] = Processor.process_delete_custom_expressions
4764  self._processMap["get_dashboard"] = Processor.process_get_dashboard
4765  self._processMap["get_dashboards"] = Processor.process_get_dashboards
4766  self._processMap["create_dashboard"] = Processor.process_create_dashboard
4767  self._processMap["replace_dashboard"] = Processor.process_replace_dashboard
4768  self._processMap["delete_dashboard"] = Processor.process_delete_dashboard
4769  self._processMap["share_dashboards"] = Processor.process_share_dashboards
4770  self._processMap["delete_dashboards"] = Processor.process_delete_dashboards
4771  self._processMap["share_dashboard"] = Processor.process_share_dashboard
4772  self._processMap["unshare_dashboard"] = Processor.process_unshare_dashboard
4773  self._processMap["unshare_dashboards"] = Processor.process_unshare_dashboards
4774  self._processMap["get_dashboard_grantees"] = Processor.process_get_dashboard_grantees
4775  self._processMap["get_link_view"] = Processor.process_get_link_view
4776  self._processMap["create_link"] = Processor.process_create_link
4777  self._processMap["load_table_binary"] = Processor.process_load_table_binary
4778  self._processMap["load_table_binary_columnar"] = Processor.process_load_table_binary_columnar
4779  self._processMap["load_table_binary_columnar_polys"] = Processor.process_load_table_binary_columnar_polys
4780  self._processMap["load_table_binary_arrow"] = Processor.process_load_table_binary_arrow
4781  self._processMap["load_table"] = Processor.process_load_table
4782  self._processMap["detect_column_types"] = Processor.process_detect_column_types
4783  self._processMap["create_table"] = Processor.process_create_table
4784  self._processMap["import_table"] = Processor.process_import_table
4785  self._processMap["import_geo_table"] = Processor.process_import_geo_table
4786  self._processMap["import_table_status"] = Processor.process_import_table_status
4787  self._processMap["get_first_geo_file_in_archive"] = Processor.process_get_first_geo_file_in_archive
4788  self._processMap["get_all_files_in_archive"] = Processor.process_get_all_files_in_archive
4789  self._processMap["get_layers_in_geo_file"] = Processor.process_get_layers_in_geo_file
4790  self._processMap["query_get_outer_fragment_count"] = Processor.process_query_get_outer_fragment_count
4791  self._processMap["check_table_consistency"] = Processor.process_check_table_consistency
4792  self._processMap["start_query"] = Processor.process_start_query
4793  self._processMap["execute_query_step"] = Processor.process_execute_query_step
4794  self._processMap["broadcast_serialized_rows"] = Processor.process_broadcast_serialized_rows
4795  self._processMap["start_render_query"] = Processor.process_start_render_query
4796  self._processMap["execute_next_render_step"] = Processor.process_execute_next_render_step
4797  self._processMap["insert_data"] = Processor.process_insert_data
4798  self._processMap["insert_chunks"] = Processor.process_insert_chunks
4799  self._processMap["checkpoint"] = Processor.process_checkpoint
4800  self._processMap["get_roles"] = Processor.process_get_roles
4801  self._processMap["get_db_objects_for_grantee"] = Processor.process_get_db_objects_for_grantee
4802  self._processMap["get_db_object_privs"] = Processor.process_get_db_object_privs
4803  self._processMap["get_all_roles_for_user"] = Processor.process_get_all_roles_for_user
4804  self._processMap["get_all_effective_roles_for_user"] = Processor.process_get_all_effective_roles_for_user
4805  self._processMap["has_role"] = Processor.process_has_role
4806  self._processMap["has_object_privilege"] = Processor.process_has_object_privilege
4807  self._processMap["set_license_key"] = Processor.process_set_license_key
4808  self._processMap["get_license_claims"] = Processor.process_get_license_claims
4809  self._processMap["get_device_parameters"] = Processor.process_get_device_parameters
4810  self._processMap["register_runtime_extension_functions"] = Processor.process_register_runtime_extension_functions
4811  self._processMap["get_table_function_names"] = Processor.process_get_table_function_names
4812  self._processMap["get_runtime_table_function_names"] = Processor.process_get_runtime_table_function_names
4813  self._processMap["get_table_function_details"] = Processor.process_get_table_function_details
4814  self._on_message_begin = None

Member Function Documentation

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

Definition at line 4815 of file Heavy.py.

References heavydb.thrift.Heavy.Processor._on_message_begin.

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

Definition at line 4818 of file Heavy.py.

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

4819  def process(self, iprot, oprot):
4820  (name, type, seqid) = iprot.readMessageBegin()
4821  if self._on_message_begin:
4822  self._on_message_begin(name, type, seqid)
4823  if name not in self._processMap:
4824  iprot.skip(TType.STRUCT)
4825  iprot.readMessageEnd()
4826  x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4827  oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4828  x.write(oprot)
4829  oprot.writeMessageEnd()
4830  oprot.trans.flush()
4831  return
4832  else:
4833  self._processMap[name](self, seqid, iprot, oprot)
4834  return True
def heavydb.thrift.Heavy.Processor.process_broadcast_serialized_rows (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6929 of file Heavy.py.

6930  def process_broadcast_serialized_rows(self, seqid, iprot, oprot):
6932  args.read(iprot)
6933  iprot.readMessageEnd()
6935  try:
6936  self._handler.broadcast_serialized_rows(args.serialized_rows, args.row_desc, args.query_id, args.subquery_id, args.is_final_subquery_result)
6937  msg_type = TMessageType.REPLY
6938  except TTransport.TTransportException:
6939  raise
6940  except TDBException as e:
6941  msg_type = TMessageType.REPLY
6942  result.e = e
6943  except TApplicationException as ex:
6944  logging.exception('TApplication exception in handler')
6945  msg_type = TMessageType.EXCEPTION
6946  result = ex
6947  except Exception:
6948  logging.exception('Unexpected exception in handler')
6949  msg_type = TMessageType.EXCEPTION
6950  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6951  oprot.writeMessageBegin("broadcast_serialized_rows", msg_type, seqid)
6952  result.write(oprot)
6953  oprot.writeMessageEnd()
6954  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_check_table_consistency (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6851 of file Heavy.py.

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

Definition at line 7059 of file Heavy.py.

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

Definition at line 5459 of file Heavy.py.

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

Definition at line 5485 of file Heavy.py.

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

Definition at line 4939 of file Heavy.py.

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

Definition at line 4835 of file Heavy.py.

4836  def process_connect(self, seqid, iprot, oprot):
4837  args = connect_args()
4838  args.read(iprot)
4839  iprot.readMessageEnd()
4840  result = connect_result()
4841  try:
4842  result.success = self._handler.connect(args.user, args.passwd, args.dbname)
4843  msg_type = TMessageType.REPLY
4844  except TTransport.TTransportException:
4845  raise
4846  except TDBException as e:
4847  msg_type = TMessageType.REPLY
4848  result.e = e
4849  except TApplicationException as ex:
4850  logging.exception('TApplication exception in handler')
4851  msg_type = TMessageType.EXCEPTION
4852  result = ex
4853  except Exception:
4854  logging.exception('Unexpected exception in handler')
4855  msg_type = TMessageType.EXCEPTION
4856  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
4857  oprot.writeMessageBegin("connect", msg_type, seqid)
4858  result.write(oprot)
4859  oprot.writeMessageEnd()
4860  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_create_custom_expression (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6045 of file Heavy.py.

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

Definition at line 6201 of file Heavy.py.

6202  def process_create_dashboard(self, seqid, iprot, oprot):
6203  args = create_dashboard_args()
6204  args.read(iprot)
6205  iprot.readMessageEnd()
6206  result = create_dashboard_result()
6207  try:
6208  result.success = self._handler.create_dashboard(args.session, args.dashboard_name, args.dashboard_state, args.image_hash, args.dashboard_metadata)
6209  msg_type = TMessageType.REPLY
6210  except TTransport.TTransportException:
6211  raise
6212  except TDBException as e:
6213  msg_type = TMessageType.REPLY
6214  result.e = e
6215  except TApplicationException as ex:
6216  logging.exception('TApplication exception in handler')
6217  msg_type = TMessageType.EXCEPTION
6218  result = ex
6219  except Exception:
6220  logging.exception('Unexpected exception in handler')
6221  msg_type = TMessageType.EXCEPTION
6222  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6223  oprot.writeMessageBegin("create_dashboard", msg_type, seqid)
6224  result.write(oprot)
6225  oprot.writeMessageEnd()
6226  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_create_link (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6461 of file Heavy.py.

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

Definition at line 6643 of file Heavy.py.

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

Definition at line 5863 of file Heavy.py.

5864  def process_deallocate_df(self, seqid, iprot, oprot):
5865  args = deallocate_df_args()
5866  args.read(iprot)
5867  iprot.readMessageEnd()
5868  result = deallocate_df_result()
5869  try:
5870  self._handler.deallocate_df(args.session, args.df, args.device_type, args.device_id)
5871  msg_type = TMessageType.REPLY
5872  except TTransport.TTransportException:
5873  raise
5874  except TDBException as e:
5875  msg_type = TMessageType.REPLY
5876  result.e = e
5877  except TApplicationException as ex:
5878  logging.exception('TApplication exception in handler')
5879  msg_type = TMessageType.EXCEPTION
5880  result = ex
5881  except Exception:
5882  logging.exception('Unexpected exception in handler')
5883  msg_type = TMessageType.EXCEPTION
5884  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5885  oprot.writeMessageBegin("deallocate_df", msg_type, seqid)
5886  result.write(oprot)
5887  oprot.writeMessageEnd()
5888  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_delete_custom_expressions (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6123 of file Heavy.py.

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

Definition at line 6253 of file Heavy.py.

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

Definition at line 6305 of file Heavy.py.

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

Definition at line 6617 of file Heavy.py.

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

Definition at line 4887 of file Heavy.py.

4888  def process_disconnect(self, seqid, iprot, oprot):
4889  args = disconnect_args()
4890  args.read(iprot)
4891  iprot.readMessageEnd()
4892  result = disconnect_result()
4893  try:
4894  self._handler.disconnect(args.session)
4895  msg_type = TMessageType.REPLY
4896  except TTransport.TTransportException:
4897  raise
4898  except TDBException as e:
4899  msg_type = TMessageType.REPLY
4900  result.e = e
4901  except TApplicationException as ex:
4902  logging.exception('TApplication exception in handler')
4903  msg_type = TMessageType.EXCEPTION
4904  result = ex
4905  except Exception:
4906  logging.exception('Unexpected exception in handler')
4907  msg_type = TMessageType.EXCEPTION
4908  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
4909  oprot.writeMessageBegin("disconnect", msg_type, seqid)
4910  result.write(oprot)
4911  oprot.writeMessageEnd()
4912  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_execute_next_render_step (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6981 of file Heavy.py.

6982  def process_execute_next_render_step(self, seqid, iprot, oprot):
6984  args.read(iprot)
6985  iprot.readMessageEnd()
6987  try:
6988  result.success = self._handler.execute_next_render_step(args.pending_render, args.merged_data)
6989  msg_type = TMessageType.REPLY
6990  except TTransport.TTransportException:
6991  raise
6992  except TDBException as e:
6993  msg_type = TMessageType.REPLY
6994  result.e = e
6995  except TApplicationException as ex:
6996  logging.exception('TApplication exception in handler')
6997  msg_type = TMessageType.EXCEPTION
6998  result = ex
6999  except Exception:
7000  logging.exception('Unexpected exception in handler')
7001  msg_type = TMessageType.EXCEPTION
7002  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7003  oprot.writeMessageBegin("execute_next_render_step", msg_type, seqid)
7004  result.write(oprot)
7005  oprot.writeMessageEnd()
7006  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_execute_query_step (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6903 of file Heavy.py.

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

Definition at line 7189 of file Heavy.py.

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

Definition at line 6773 of file Heavy.py.

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

Definition at line 7163 of file Heavy.py.

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

Definition at line 5941 of file Heavy.py.

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

Definition at line 6071 of file Heavy.py.

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

Definition at line 6149 of file Heavy.py.

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

Definition at line 6409 of file Heavy.py.

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

Definition at line 6175 of file Heavy.py.

6176  def process_get_dashboards(self, seqid, iprot, oprot):
6177  args = get_dashboards_args()
6178  args.read(iprot)
6179  iprot.readMessageEnd()
6180  result = get_dashboards_result()
6181  try:
6182  result.success = self._handler.get_dashboards(args.session)
6183  msg_type = TMessageType.REPLY
6184  except TTransport.TTransportException:
6185  raise
6186  except TDBException as e:
6187  msg_type = TMessageType.REPLY
6188  result.e = e
6189  except TApplicationException as ex:
6190  logging.exception('TApplication exception in handler')
6191  msg_type = TMessageType.EXCEPTION
6192  result = ex
6193  except Exception:
6194  logging.exception('Unexpected exception in handler')
6195  msg_type = TMessageType.EXCEPTION
6196  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6197  oprot.writeMessageBegin("get_dashboards", msg_type, seqid)
6198  result.write(oprot)
6199  oprot.writeMessageEnd()
6200  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_databases (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5303 of file Heavy.py.

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

Definition at line 7137 of file Heavy.py.

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

Definition at line 7111 of file Heavy.py.

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

Definition at line 7319 of file Heavy.py.

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

Definition at line 6747 of file Heavy.py.

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

Definition at line 5017 of file Heavy.py.

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

Definition at line 5407 of file Heavy.py.

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

Definition at line 5225 of file Heavy.py.

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

Definition at line 5251 of file Heavy.py.

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

Definition at line 6799 of file Heavy.py.

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

Definition at line 7293 of file Heavy.py.

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

Definition at line 6435 of file Heavy.py.

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

Definition at line 5433 of file Heavy.py.

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

Definition at line 5095 of file Heavy.py.

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

Definition at line 5733 of file Heavy.py.

5734  def process_get_queries_info(self, seqid, iprot, oprot):
5735  args = get_queries_info_args()
5736  args.read(iprot)
5737  iprot.readMessageEnd()
5738  result = get_queries_info_result()
5739  try:
5740  result.success = self._handler.get_queries_info(args.session)
5741  msg_type = TMessageType.REPLY
5742  except TTransport.TTransportException:
5743  raise
5744  except TDBException as e:
5745  msg_type = TMessageType.REPLY
5746  result.e = e
5747  except TApplicationException as ex:
5748  logging.exception('TApplication exception in handler')
5749  msg_type = TMessageType.EXCEPTION
5750  result = ex
5751  except Exception:
5752  logging.exception('Unexpected exception in handler')
5753  msg_type = TMessageType.EXCEPTION
5754  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5755  oprot.writeMessageBegin("get_queries_info", msg_type, seqid)
5756  result.write(oprot)
5757  oprot.writeMessageEnd()
5758  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_result_row_for_pixel (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6019 of file Heavy.py.

6020  def process_get_result_row_for_pixel(self, seqid, iprot, oprot):
6022  args.read(iprot)
6023  iprot.readMessageEnd()
6025  try:
6026  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)
6027  msg_type = TMessageType.REPLY
6028  except TTransport.TTransportException:
6029  raise
6030  except TDBException as e:
6031  msg_type = TMessageType.REPLY
6032  result.e = e
6033  except TApplicationException as ex:
6034  logging.exception('TApplication exception in handler')
6035  msg_type = TMessageType.EXCEPTION
6036  result = ex
6037  except Exception:
6038  logging.exception('Unexpected exception in handler')
6039  msg_type = TMessageType.EXCEPTION
6040  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6041  oprot.writeMessageBegin("get_result_row_for_pixel", msg_type, seqid)
6042  result.write(oprot)
6043  oprot.writeMessageEnd()
6044  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_roles (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7085 of file Heavy.py.

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

Definition at line 7397 of file Heavy.py.

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

Definition at line 4965 of file Heavy.py.

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

Definition at line 5707 of file Heavy.py.

5708  def process_get_session_info(self, seqid, iprot, oprot):
5709  args = get_session_info_args()
5710  args.read(iprot)
5711  iprot.readMessageEnd()
5712  result = get_session_info_result()
5713  try:
5714  result.success = self._handler.get_session_info(args.session)
5715  msg_type = TMessageType.REPLY
5716  except TTransport.TTransportException:
5717  raise
5718  except TDBException as e:
5719  msg_type = TMessageType.REPLY
5720  result.e = e
5721  except TApplicationException as ex:
5722  logging.exception('TApplication exception in handler')
5723  msg_type = TMessageType.EXCEPTION
5724  result = ex
5725  except Exception:
5726  logging.exception('Unexpected exception in handler')
5727  msg_type = TMessageType.EXCEPTION
5728  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5729  oprot.writeMessageBegin("get_session_info", msg_type, seqid)
5730  result.write(oprot)
5731  oprot.writeMessageEnd()
5732  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_status (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 4991 of file Heavy.py.

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

Definition at line 5173 of file Heavy.py.

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

Definition at line 5199 of file Heavy.py.

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

Definition at line 5615 of file Heavy.py.

5616  def process_get_table_epoch(self, seqid, iprot, oprot):
5617  args = get_table_epoch_args()
5618  args.read(iprot)
5619  iprot.readMessageEnd()
5620  result = get_table_epoch_result()
5621  try:
5622  result.success = self._handler.get_table_epoch(args.session, args.db_id, args.table_id)
5623  msg_type = TMessageType.REPLY
5624  except TTransport.TTransportException:
5625  raise
5626  except TApplicationException as ex:
5627  logging.exception('TApplication exception in handler')
5628  msg_type = TMessageType.EXCEPTION
5629  result = ex
5630  except Exception:
5631  logging.exception('Unexpected exception in handler')
5632  msg_type = TMessageType.EXCEPTION
5633  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5634  oprot.writeMessageBegin("get_table_epoch", msg_type, seqid)
5635  result.write(oprot)
5636  oprot.writeMessageEnd()
5637  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_epoch_by_name (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5638 of file Heavy.py.

5639  def process_get_table_epoch_by_name(self, seqid, iprot, oprot):
5641  args.read(iprot)
5642  iprot.readMessageEnd()
5644  try:
5645  result.success = self._handler.get_table_epoch_by_name(args.session, args.table_name)
5646  msg_type = TMessageType.REPLY
5647  except TTransport.TTransportException:
5648  raise
5649  except TApplicationException as ex:
5650  logging.exception('TApplication exception in handler')
5651  msg_type = TMessageType.EXCEPTION
5652  result = ex
5653  except Exception:
5654  logging.exception('Unexpected exception in handler')
5655  msg_type = TMessageType.EXCEPTION
5656  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5657  oprot.writeMessageBegin("get_table_epoch_by_name", msg_type, seqid)
5658  result.write(oprot)
5659  oprot.writeMessageEnd()
5660  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_epochs (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5661 of file Heavy.py.

5662  def process_get_table_epochs(self, seqid, iprot, oprot):
5663  args = get_table_epochs_args()
5664  args.read(iprot)
5665  iprot.readMessageEnd()
5666  result = get_table_epochs_result()
5667  try:
5668  result.success = self._handler.get_table_epochs(args.session, args.db_id, args.table_id)
5669  msg_type = TMessageType.REPLY
5670  except TTransport.TTransportException:
5671  raise
5672  except TApplicationException as ex:
5673  logging.exception('TApplication exception in handler')
5674  msg_type = TMessageType.EXCEPTION
5675  result = ex
5676  except Exception:
5677  logging.exception('Unexpected exception in handler')
5678  msg_type = TMessageType.EXCEPTION
5679  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5680  oprot.writeMessageBegin("get_table_epochs", msg_type, seqid)
5681  result.write(oprot)
5682  oprot.writeMessageEnd()
5683  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_function_details (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7423 of file Heavy.py.

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

Definition at line 7371 of file Heavy.py.

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

Definition at line 5043 of file Heavy.py.

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

Definition at line 5069 of file Heavy.py.

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

Definition at line 5147 of file Heavy.py.

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

Definition at line 5277 of file Heavy.py.

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

Definition at line 5329 of file Heavy.py.

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

Definition at line 5121 of file Heavy.py.

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

Definition at line 7241 of file Heavy.py.

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

Definition at line 7215 of file Heavy.py.

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

Definition at line 6695 of file Heavy.py.

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

Definition at line 6669 of file Heavy.py.

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

Definition at line 6721 of file Heavy.py.

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

Definition at line 7033 of file Heavy.py.

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

Definition at line 7007 of file Heavy.py.

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

Definition at line 5889 of file Heavy.py.

5890  def process_interrupt(self, seqid, iprot, oprot):
5891  args = interrupt_args()
5892  args.read(iprot)
5893  iprot.readMessageEnd()
5894  result = interrupt_result()
5895  try:
5896  self._handler.interrupt(args.query_session, args.interrupt_session)
5897  msg_type = TMessageType.REPLY
5898  except TTransport.TTransportException:
5899  raise
5900  except TDBException as e:
5901  msg_type = TMessageType.REPLY
5902  result.e = e
5903  except TApplicationException as ex:
5904  logging.exception('TApplication exception in handler')
5905  msg_type = TMessageType.EXCEPTION
5906  result = ex
5907  except Exception:
5908  logging.exception('Unexpected exception in handler')
5909  msg_type = TMessageType.EXCEPTION
5910  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5911  oprot.writeMessageBegin("interrupt", msg_type, seqid)
5912  result.write(oprot)
5913  oprot.writeMessageEnd()
5914  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_invalidate_cur_session (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5537 of file Heavy.py.

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

Definition at line 4861 of file Heavy.py.

4862  def process_krb5_connect(self, seqid, iprot, oprot):
4863  args = krb5_connect_args()
4864  args.read(iprot)
4865  iprot.readMessageEnd()
4866  result = krb5_connect_result()
4867  try:
4868  result.success = self._handler.krb5_connect(args.inputToken, args.dbname)
4869  msg_type = TMessageType.REPLY
4870  except TTransport.TTransportException:
4871  raise
4872  except TDBException as e:
4873  msg_type = TMessageType.REPLY
4874  result.e = e
4875  except TApplicationException as ex:
4876  logging.exception('TApplication exception in handler')
4877  msg_type = TMessageType.EXCEPTION
4878  result = ex
4879  except Exception:
4880  logging.exception('Unexpected exception in handler')
4881  msg_type = TMessageType.EXCEPTION
4882  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
4883  oprot.writeMessageBegin("krb5_connect", msg_type, seqid)
4884  result.write(oprot)
4885  oprot.writeMessageEnd()
4886  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_load_table (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6591 of file Heavy.py.

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

Definition at line 6487 of file Heavy.py.

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

Definition at line 6565 of file Heavy.py.

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

Definition at line 6513 of file Heavy.py.

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

Definition at line 6539 of file Heavy.py.

6540  def process_load_table_binary_columnar_polys(self, seqid, iprot, oprot):
6542  args.read(iprot)
6543  iprot.readMessageEnd()
6545  try:
6546  self._handler.load_table_binary_columnar_polys(args.session, args.table_name, args.cols, args.column_names, args.assign_render_groups)
6547  msg_type = TMessageType.REPLY
6548  except TTransport.TTransportException:
6549  raise
6550  except TDBException as e:
6551  msg_type = TMessageType.REPLY
6552  result.e = e
6553  except TApplicationException as ex:
6554  logging.exception('TApplication exception in handler')
6555  msg_type = TMessageType.EXCEPTION
6556  result = ex
6557  except Exception:
6558  logging.exception('Unexpected exception in handler')
6559  msg_type = TMessageType.EXCEPTION
6560  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6561  oprot.writeMessageBegin("load_table_binary_columnar_polys", msg_type, seqid)
6562  result.write(oprot)
6563  oprot.writeMessageEnd()
6564  oprot.trans.flush()
def process_load_table_binary_columnar_polys
Definition: Heavy.py:6539
def heavydb.thrift.Heavy.Processor.process_query_get_outer_fragment_count (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6825 of file Heavy.py.

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

Definition at line 7345 of file Heavy.py.

7346  def process_register_runtime_extension_functions(self, seqid, iprot, oprot):
7348  args.read(iprot)
7349  iprot.readMessageEnd()
7351  try:
7352  self._handler.register_runtime_extension_functions(args.session, args.udfs, args.udtfs, args.device_ir_map)
7353  msg_type = TMessageType.REPLY
7354  except TTransport.TTransportException:
7355  raise
7356  except TDBException as e:
7357  msg_type = TMessageType.REPLY
7358  result.e = e
7359  except TApplicationException as ex:
7360  logging.exception('TApplication exception in handler')
7361  msg_type = TMessageType.EXCEPTION
7362  result = ex
7363  except Exception:
7364  logging.exception('Unexpected exception in handler')
7365  msg_type = TMessageType.EXCEPTION
7366  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7367  oprot.writeMessageBegin("register_runtime_extension_functions", msg_type, seqid)
7368  result.write(oprot)
7369  oprot.writeMessageEnd()
7370  oprot.trans.flush()
def process_register_runtime_extension_functions
Definition: Heavy.py:7345
def heavydb.thrift.Heavy.Processor.process_render_vega (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5993 of file Heavy.py.

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

Definition at line 6227 of file Heavy.py.

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

Definition at line 5511 of file Heavy.py.

5512  def process_set_cur_session(self, seqid, iprot, oprot):
5513  args = set_cur_session_args()
5514  args.read(iprot)
5515  iprot.readMessageEnd()
5516  result = set_cur_session_result()
5517  try:
5518  self._handler.set_cur_session(args.parent_session, args.leaf_session, args.start_time_str, args.label, args.for_running_query_kernel)
5519  msg_type = TMessageType.REPLY
5520  except TTransport.TTransportException:
5521  raise
5522  except TDBException as e:
5523  msg_type = TMessageType.REPLY
5524  result.e = e
5525  except TApplicationException as ex:
5526  logging.exception('TApplication exception in handler')
5527  msg_type = TMessageType.EXCEPTION
5528  result = ex
5529  except Exception:
5530  logging.exception('Unexpected exception in handler')
5531  msg_type = TMessageType.EXCEPTION
5532  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5533  oprot.writeMessageBegin("set_cur_session", msg_type, seqid)
5534  result.write(oprot)
5535  oprot.writeMessageEnd()
5536  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_execution_mode (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5967 of file Heavy.py.

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

Definition at line 5759 of file Heavy.py.

5760  def process_set_leaf_info(self, seqid, iprot, oprot):
5761  args = set_leaf_info_args()
5762  args.read(iprot)
5763  iprot.readMessageEnd()
5764  result = set_leaf_info_result()
5765  try:
5766  self._handler.set_leaf_info(args.session, args.leaf_info)
5767  msg_type = TMessageType.REPLY
5768  except TTransport.TTransportException:
5769  raise
5770  except TDBException as e:
5771  msg_type = TMessageType.REPLY
5772  result.e = e
5773  except TApplicationException as ex:
5774  logging.exception('TApplication exception in handler')
5775  msg_type = TMessageType.EXCEPTION
5776  result = ex
5777  except Exception:
5778  logging.exception('Unexpected exception in handler')
5779  msg_type = TMessageType.EXCEPTION
5780  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5781  oprot.writeMessageBegin("set_leaf_info", msg_type, seqid)
5782  result.write(oprot)
5783  oprot.writeMessageEnd()
5784  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_license_key (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7267 of file Heavy.py.

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

Definition at line 5563 of file Heavy.py.

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

Definition at line 5589 of file Heavy.py.

5590  def process_set_table_epoch_by_name(self, seqid, iprot, oprot):
5592  args.read(iprot)
5593  iprot.readMessageEnd()
5595  try:
5596  self._handler.set_table_epoch_by_name(args.session, args.table_name, args.new_epoch)
5597  msg_type = TMessageType.REPLY
5598  except TTransport.TTransportException:
5599  raise
5600  except TDBException as e:
5601  msg_type = TMessageType.REPLY
5602  result.e = e
5603  except TApplicationException as ex:
5604  logging.exception('TApplication exception in handler')
5605  msg_type = TMessageType.EXCEPTION
5606  result = ex
5607  except Exception:
5608  logging.exception('Unexpected exception in handler')
5609  msg_type = TMessageType.EXCEPTION
5610  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5611  oprot.writeMessageBegin("set_table_epoch_by_name", msg_type, seqid)
5612  result.write(oprot)
5613  oprot.writeMessageEnd()
5614  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_table_epochs (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5684 of file Heavy.py.

5685  def process_set_table_epochs(self, seqid, iprot, oprot):
5686  args = set_table_epochs_args()
5687  args.read(iprot)
5688  iprot.readMessageEnd()
5689  result = set_table_epochs_result()
5690  try:
5691  self._handler.set_table_epochs(args.session, args.db_id, args.table_epochs)
5692  msg_type = TMessageType.REPLY
5693  except TTransport.TTransportException:
5694  raise
5695  except TApplicationException as ex:
5696  logging.exception('TApplication exception in handler')
5697  msg_type = TMessageType.EXCEPTION
5698  result = ex
5699  except Exception:
5700  logging.exception('Unexpected exception in handler')
5701  msg_type = TMessageType.EXCEPTION
5702  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5703  oprot.writeMessageBegin("set_table_epochs", msg_type, seqid)
5704  result.write(oprot)
5705  oprot.writeMessageEnd()
5706  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_share_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6331 of file Heavy.py.

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

Definition at line 6279 of file Heavy.py.

6280  def process_share_dashboards(self, seqid, iprot, oprot):
6281  args = share_dashboards_args()
6282  args.read(iprot)
6283  iprot.readMessageEnd()
6284  result = share_dashboards_result()
6285  try:
6286  self._handler.share_dashboards(args.session, args.dashboard_ids, args.groups, args.permissions)
6287  msg_type = TMessageType.REPLY
6288  except TTransport.TTransportException:
6289  raise
6290  except TDBException as e:
6291  msg_type = TMessageType.REPLY
6292  result.e = e
6293  except TApplicationException as ex:
6294  logging.exception('TApplication exception in handler')
6295  msg_type = TMessageType.EXCEPTION
6296  result = ex
6297  except Exception:
6298  logging.exception('Unexpected exception in handler')
6299  msg_type = TMessageType.EXCEPTION
6300  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6301  oprot.writeMessageBegin("share_dashboards", msg_type, seqid)
6302  result.write(oprot)
6303  oprot.writeMessageEnd()
6304  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_sql_execute (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5785 of file Heavy.py.

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

Definition at line 5811 of file Heavy.py.

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

Definition at line 5837 of file Heavy.py.

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

Definition at line 5915 of file Heavy.py.

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

Definition at line 5355 of file Heavy.py.

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

Definition at line 6877 of file Heavy.py.

6878  def process_start_query(self, seqid, iprot, oprot):
6879  args = start_query_args()
6880  args.read(iprot)
6881  iprot.readMessageEnd()
6882  result = start_query_result()
6883  try:
6884  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)
6885  msg_type = TMessageType.REPLY
6886  except TTransport.TTransportException:
6887  raise
6888  except TDBException as e:
6889  msg_type = TMessageType.REPLY
6890  result.e = e
6891  except TApplicationException as ex:
6892  logging.exception('TApplication exception in handler')
6893  msg_type = TMessageType.EXCEPTION
6894  result = ex
6895  except Exception:
6896  logging.exception('Unexpected exception in handler')
6897  msg_type = TMessageType.EXCEPTION
6898  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6899  oprot.writeMessageBegin("start_query", msg_type, seqid)
6900  result.write(oprot)
6901  oprot.writeMessageEnd()
6902  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_start_render_query (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6955 of file Heavy.py.

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

Definition at line 5381 of file Heavy.py.

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

Definition at line 4913 of file Heavy.py.

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

Definition at line 6357 of file Heavy.py.

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

Definition at line 6383 of file Heavy.py.

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

Definition at line 6097 of file Heavy.py.

6098  def process_update_custom_expression(self, seqid, iprot, oprot):
6100  args.read(iprot)
6101  iprot.readMessageEnd()
6103  try:
6104  self._handler.update_custom_expression(args.session, args.id, args.expression_json)
6105  msg_type = TMessageType.REPLY
6106  except TTransport.TTransportException:
6107  raise
6108  except TDBException as e:
6109  msg_type = TMessageType.REPLY
6110  result.e = e
6111  except TApplicationException as ex:
6112  logging.exception('TApplication exception in handler')
6113  msg_type = TMessageType.EXCEPTION
6114  result = ex
6115  except Exception:
6116  logging.exception('Unexpected exception in handler')
6117  msg_type = TMessageType.EXCEPTION
6118  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6119  oprot.writeMessageBegin("update_custom_expression", msg_type, seqid)
6120  result.write(oprot)
6121  oprot.writeMessageEnd()
6122  oprot.trans.flush()

Member Data Documentation

heavydb.thrift.Heavy.Processor._handler
private

Definition at line 4710 of file Heavy.py.

heavydb.thrift.Heavy.Processor._on_message_begin
private

Definition at line 4813 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 4711 of file Heavy.py.

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


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