OmniSciDB  b28c0d5765
 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
 
def process_get_function_names
 
def process_get_runtime_function_names
 
def process_get_function_details
 
- Public Member Functions inherited from heavydb.thrift.Heavy.Iface
def connect
 
def krb5_connect
 
def disconnect
 
def switch_database
 
def clone_session
 
def get_server_status
 
def get_status
 
def get_hardware_info
 
def get_tables
 
def get_tables_for_database
 
def get_physical_tables
 
def get_views
 
def get_tables_meta
 
def get_table_details
 
def get_table_details_for_database
 
def get_internal_table_details
 
def get_internal_table_details_for_database
 
def get_users
 
def get_databases
 
def get_version
 
def start_heap_profile
 
def stop_heap_profile
 
def get_heap_profile
 
def get_memory
 
def clear_cpu_memory
 
def clear_gpu_memory
 
def set_cur_session
 
def invalidate_cur_session
 
def set_table_epoch
 
def set_table_epoch_by_name
 
def get_table_epoch
 
def get_table_epoch_by_name
 
def get_table_epochs
 
def set_table_epochs
 
def get_session_info
 
def get_queries_info
 
def set_leaf_info
 
def sql_execute
 
def sql_execute_df
 
def sql_execute_gdf
 
def deallocate_df
 
def interrupt
 
def sql_validate
 
def get_completion_hints
 
def set_execution_mode
 
def render_vega
 
def get_result_row_for_pixel
 
def create_custom_expression
 
def get_custom_expressions
 
def update_custom_expression
 
def delete_custom_expressions
 
def get_dashboard
 
def get_dashboards
 
def create_dashboard
 
def replace_dashboard
 
def delete_dashboard
 
def share_dashboards
 
def delete_dashboards
 
def share_dashboard
 
def unshare_dashboard
 
def unshare_dashboards
 
def get_dashboard_grantees
 
def get_link_view
 
def create_link
 
def load_table_binary
 
def load_table_binary_columnar
 
def load_table_binary_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
 
def get_function_names
 
def get_runtime_function_names
 
def get_function_details
 

Private Attributes

 _handler
 
 _processMap
 
 _on_message_begin
 

Detailed Description

Definition at line 4837 of file Heavy.py.

Constructor & Destructor Documentation

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

Definition at line 4838 of file Heavy.py.

4839  def __init__(self, handler):
4840  self._handler = handler
4841  self._processMap = {}
4842  self._processMap["connect"] = Processor.process_connect
4843  self._processMap["krb5_connect"] = Processor.process_krb5_connect
4844  self._processMap["disconnect"] = Processor.process_disconnect
4845  self._processMap["switch_database"] = Processor.process_switch_database
4846  self._processMap["clone_session"] = Processor.process_clone_session
4847  self._processMap["get_server_status"] = Processor.process_get_server_status
4848  self._processMap["get_status"] = Processor.process_get_status
4849  self._processMap["get_hardware_info"] = Processor.process_get_hardware_info
4850  self._processMap["get_tables"] = Processor.process_get_tables
4851  self._processMap["get_tables_for_database"] = Processor.process_get_tables_for_database
4852  self._processMap["get_physical_tables"] = Processor.process_get_physical_tables
4853  self._processMap["get_views"] = Processor.process_get_views
4854  self._processMap["get_tables_meta"] = Processor.process_get_tables_meta
4855  self._processMap["get_table_details"] = Processor.process_get_table_details
4856  self._processMap["get_table_details_for_database"] = Processor.process_get_table_details_for_database
4857  self._processMap["get_internal_table_details"] = Processor.process_get_internal_table_details
4858  self._processMap["get_internal_table_details_for_database"] = Processor.process_get_internal_table_details_for_database
4859  self._processMap["get_users"] = Processor.process_get_users
4860  self._processMap["get_databases"] = Processor.process_get_databases
4861  self._processMap["get_version"] = Processor.process_get_version
4862  self._processMap["start_heap_profile"] = Processor.process_start_heap_profile
4863  self._processMap["stop_heap_profile"] = Processor.process_stop_heap_profile
4864  self._processMap["get_heap_profile"] = Processor.process_get_heap_profile
4865  self._processMap["get_memory"] = Processor.process_get_memory
4866  self._processMap["clear_cpu_memory"] = Processor.process_clear_cpu_memory
4867  self._processMap["clear_gpu_memory"] = Processor.process_clear_gpu_memory
4868  self._processMap["set_cur_session"] = Processor.process_set_cur_session
4869  self._processMap["invalidate_cur_session"] = Processor.process_invalidate_cur_session
4870  self._processMap["set_table_epoch"] = Processor.process_set_table_epoch
4871  self._processMap["set_table_epoch_by_name"] = Processor.process_set_table_epoch_by_name
4872  self._processMap["get_table_epoch"] = Processor.process_get_table_epoch
4873  self._processMap["get_table_epoch_by_name"] = Processor.process_get_table_epoch_by_name
4874  self._processMap["get_table_epochs"] = Processor.process_get_table_epochs
4875  self._processMap["set_table_epochs"] = Processor.process_set_table_epochs
4876  self._processMap["get_session_info"] = Processor.process_get_session_info
4877  self._processMap["get_queries_info"] = Processor.process_get_queries_info
4878  self._processMap["set_leaf_info"] = Processor.process_set_leaf_info
4879  self._processMap["sql_execute"] = Processor.process_sql_execute
4880  self._processMap["sql_execute_df"] = Processor.process_sql_execute_df
4881  self._processMap["sql_execute_gdf"] = Processor.process_sql_execute_gdf
4882  self._processMap["deallocate_df"] = Processor.process_deallocate_df
4883  self._processMap["interrupt"] = Processor.process_interrupt
4884  self._processMap["sql_validate"] = Processor.process_sql_validate
4885  self._processMap["get_completion_hints"] = Processor.process_get_completion_hints
4886  self._processMap["set_execution_mode"] = Processor.process_set_execution_mode
4887  self._processMap["render_vega"] = Processor.process_render_vega
4888  self._processMap["get_result_row_for_pixel"] = Processor.process_get_result_row_for_pixel
4889  self._processMap["create_custom_expression"] = Processor.process_create_custom_expression
4890  self._processMap["get_custom_expressions"] = Processor.process_get_custom_expressions
4891  self._processMap["update_custom_expression"] = Processor.process_update_custom_expression
4892  self._processMap["delete_custom_expressions"] = Processor.process_delete_custom_expressions
4893  self._processMap["get_dashboard"] = Processor.process_get_dashboard
4894  self._processMap["get_dashboards"] = Processor.process_get_dashboards
4895  self._processMap["create_dashboard"] = Processor.process_create_dashboard
4896  self._processMap["replace_dashboard"] = Processor.process_replace_dashboard
4897  self._processMap["delete_dashboard"] = Processor.process_delete_dashboard
4898  self._processMap["share_dashboards"] = Processor.process_share_dashboards
4899  self._processMap["delete_dashboards"] = Processor.process_delete_dashboards
4900  self._processMap["share_dashboard"] = Processor.process_share_dashboard
4901  self._processMap["unshare_dashboard"] = Processor.process_unshare_dashboard
4902  self._processMap["unshare_dashboards"] = Processor.process_unshare_dashboards
4903  self._processMap["get_dashboard_grantees"] = Processor.process_get_dashboard_grantees
4904  self._processMap["get_link_view"] = Processor.process_get_link_view
4905  self._processMap["create_link"] = Processor.process_create_link
4906  self._processMap["load_table_binary"] = Processor.process_load_table_binary
4907  self._processMap["load_table_binary_columnar"] = Processor.process_load_table_binary_columnar
4908  self._processMap["load_table_binary_columnar_polys"] = Processor.process_load_table_binary_columnar_polys
4909  self._processMap["load_table_binary_arrow"] = Processor.process_load_table_binary_arrow
4910  self._processMap["load_table"] = Processor.process_load_table
4911  self._processMap["detect_column_types"] = Processor.process_detect_column_types
4912  self._processMap["create_table"] = Processor.process_create_table
4913  self._processMap["import_table"] = Processor.process_import_table
4914  self._processMap["import_geo_table"] = Processor.process_import_geo_table
4915  self._processMap["import_table_status"] = Processor.process_import_table_status
4916  self._processMap["get_first_geo_file_in_archive"] = Processor.process_get_first_geo_file_in_archive
4917  self._processMap["get_all_files_in_archive"] = Processor.process_get_all_files_in_archive
4918  self._processMap["get_layers_in_geo_file"] = Processor.process_get_layers_in_geo_file
4919  self._processMap["query_get_outer_fragment_count"] = Processor.process_query_get_outer_fragment_count
4920  self._processMap["check_table_consistency"] = Processor.process_check_table_consistency
4921  self._processMap["start_query"] = Processor.process_start_query
4922  self._processMap["execute_query_step"] = Processor.process_execute_query_step
4923  self._processMap["broadcast_serialized_rows"] = Processor.process_broadcast_serialized_rows
4924  self._processMap["start_render_query"] = Processor.process_start_render_query
4925  self._processMap["execute_next_render_step"] = Processor.process_execute_next_render_step
4926  self._processMap["insert_data"] = Processor.process_insert_data
4927  self._processMap["insert_chunks"] = Processor.process_insert_chunks
4928  self._processMap["checkpoint"] = Processor.process_checkpoint
4929  self._processMap["get_roles"] = Processor.process_get_roles
4930  self._processMap["get_db_objects_for_grantee"] = Processor.process_get_db_objects_for_grantee
4931  self._processMap["get_db_object_privs"] = Processor.process_get_db_object_privs
4932  self._processMap["get_all_roles_for_user"] = Processor.process_get_all_roles_for_user
4933  self._processMap["get_all_effective_roles_for_user"] = Processor.process_get_all_effective_roles_for_user
4934  self._processMap["has_role"] = Processor.process_has_role
4935  self._processMap["has_object_privilege"] = Processor.process_has_object_privilege
4936  self._processMap["set_license_key"] = Processor.process_set_license_key
4937  self._processMap["get_license_claims"] = Processor.process_get_license_claims
4938  self._processMap["get_device_parameters"] = Processor.process_get_device_parameters
4939  self._processMap["register_runtime_extension_functions"] = Processor.process_register_runtime_extension_functions
4940  self._processMap["get_table_function_names"] = Processor.process_get_table_function_names
4941  self._processMap["get_runtime_table_function_names"] = Processor.process_get_runtime_table_function_names
4942  self._processMap["get_table_function_details"] = Processor.process_get_table_function_details
4943  self._processMap["get_function_names"] = Processor.process_get_function_names
4944  self._processMap["get_runtime_function_names"] = Processor.process_get_runtime_function_names
4945  self._processMap["get_function_details"] = Processor.process_get_function_details
4946  self._on_message_begin = None

Member Function Documentation

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

Definition at line 4947 of file Heavy.py.

References heavydb.thrift.Heavy.Processor._on_message_begin.

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

Definition at line 4950 of file Heavy.py.

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

4951  def process(self, iprot, oprot):
4952  (name, type, seqid) = iprot.readMessageBegin()
4953  if self._on_message_begin:
4954  self._on_message_begin(name, type, seqid)
4955  if name not in self._processMap:
4956  iprot.skip(TType.STRUCT)
4957  iprot.readMessageEnd()
4958  x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4959  oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4960  x.write(oprot)
4961  oprot.writeMessageEnd()
4962  oprot.trans.flush()
4963  return
4964  else:
4965  self._processMap[name](self, seqid, iprot, oprot)
4966  return True
def heavydb.thrift.Heavy.Processor.process_broadcast_serialized_rows (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7061 of file Heavy.py.

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

Definition at line 6983 of file Heavy.py.

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

Definition at line 7191 of file Heavy.py.

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

Definition at line 5591 of file Heavy.py.

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

Definition at line 5617 of file Heavy.py.

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

Definition at line 5071 of file Heavy.py.

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

Definition at line 4967 of file Heavy.py.

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

Definition at line 6177 of file Heavy.py.

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

Definition at line 6333 of file Heavy.py.

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

Definition at line 6593 of file Heavy.py.

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

Definition at line 6775 of file Heavy.py.

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

Definition at line 5995 of file Heavy.py.

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

Definition at line 6255 of file Heavy.py.

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

Definition at line 6385 of file Heavy.py.

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

Definition at line 6437 of file Heavy.py.

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

Definition at line 6749 of file Heavy.py.

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

Definition at line 5019 of file Heavy.py.

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

Definition at line 7113 of file Heavy.py.

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

Definition at line 7035 of file Heavy.py.

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

Definition at line 7321 of file Heavy.py.

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

Definition at line 6905 of file Heavy.py.

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

Definition at line 7295 of file Heavy.py.

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

Definition at line 6073 of file Heavy.py.

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

Definition at line 6203 of file Heavy.py.

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

Definition at line 6281 of file Heavy.py.

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

Definition at line 6541 of file Heavy.py.

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

Definition at line 6307 of file Heavy.py.

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

Definition at line 5435 of file Heavy.py.

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

Definition at line 7269 of file Heavy.py.

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

Definition at line 7243 of file Heavy.py.

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

Definition at line 7451 of file Heavy.py.

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

Definition at line 6879 of file Heavy.py.

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

Definition at line 7633 of file Heavy.py.

7634  def process_get_function_details(self, seqid, iprot, oprot):
7635  args = get_function_details_args()
7636  args.read(iprot)
7637  iprot.readMessageEnd()
7638  result = get_function_details_result()
7639  try:
7640  result.success = self._handler.get_function_details(args.session, args.udf_names)
7641  msg_type = TMessageType.REPLY
7642  except TTransport.TTransportException:
7643  raise
7644  except TDBException as e:
7645  msg_type = TMessageType.REPLY
7646  result.e = e
7647  except TApplicationException as ex:
7648  logging.exception('TApplication exception in handler')
7649  msg_type = TMessageType.EXCEPTION
7650  result = ex
7651  except Exception:
7652  logging.exception('Unexpected exception in handler')
7653  msg_type = TMessageType.EXCEPTION
7654  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7655  oprot.writeMessageBegin("get_function_details", msg_type, seqid)
7656  result.write(oprot)
7657  oprot.writeMessageEnd()
7658  oprot.trans.flush()
7659 
7660 # HELPER FUNCTIONS AND STRUCTURES
7661 
def heavydb.thrift.Heavy.Processor.process_get_function_names (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7581 of file Heavy.py.

7582  def process_get_function_names(self, seqid, iprot, oprot):
7583  args = get_function_names_args()
7584  args.read(iprot)
7585  iprot.readMessageEnd()
7586  result = get_function_names_result()
7587  try:
7588  result.success = self._handler.get_function_names(args.session)
7589  msg_type = TMessageType.REPLY
7590  except TTransport.TTransportException:
7591  raise
7592  except TDBException as e:
7593  msg_type = TMessageType.REPLY
7594  result.e = e
7595  except TApplicationException as ex:
7596  logging.exception('TApplication exception in handler')
7597  msg_type = TMessageType.EXCEPTION
7598  result = ex
7599  except Exception:
7600  logging.exception('Unexpected exception in handler')
7601  msg_type = TMessageType.EXCEPTION
7602  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7603  oprot.writeMessageBegin("get_function_names", msg_type, seqid)
7604  result.write(oprot)
7605  oprot.writeMessageEnd()
7606  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_hardware_info (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5149 of file Heavy.py.

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

Definition at line 5539 of file Heavy.py.

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

Definition at line 5357 of file Heavy.py.

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

Definition at line 5383 of file Heavy.py.

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

Definition at line 6931 of file Heavy.py.

6932  def process_get_layers_in_geo_file(self, seqid, iprot, oprot):
6934  args.read(iprot)
6935  iprot.readMessageEnd()
6937  try:
6938  result.success = self._handler.get_layers_in_geo_file(args.session, args.file_name, args.copy_params)
6939  msg_type = TMessageType.REPLY
6940  except TTransport.TTransportException:
6941  raise
6942  except TDBException as e:
6943  msg_type = TMessageType.REPLY
6944  result.e = e
6945  except TApplicationException as ex:
6946  logging.exception('TApplication exception in handler')
6947  msg_type = TMessageType.EXCEPTION
6948  result = ex
6949  except Exception:
6950  logging.exception('Unexpected exception in handler')
6951  msg_type = TMessageType.EXCEPTION
6952  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6953  oprot.writeMessageBegin("get_layers_in_geo_file", msg_type, seqid)
6954  result.write(oprot)
6955  oprot.writeMessageEnd()
6956  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_license_claims (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7425 of file Heavy.py.

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

Definition at line 6567 of file Heavy.py.

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

Definition at line 5565 of file Heavy.py.

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

Definition at line 5227 of file Heavy.py.

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

Definition at line 5865 of file Heavy.py.

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

Definition at line 6151 of file Heavy.py.

6152  def process_get_result_row_for_pixel(self, seqid, iprot, oprot):
6154  args.read(iprot)
6155  iprot.readMessageEnd()
6157  try:
6158  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)
6159  msg_type = TMessageType.REPLY
6160  except TTransport.TTransportException:
6161  raise
6162  except TDBException as e:
6163  msg_type = TMessageType.REPLY
6164  result.e = e
6165  except TApplicationException as ex:
6166  logging.exception('TApplication exception in handler')
6167  msg_type = TMessageType.EXCEPTION
6168  result = ex
6169  except Exception:
6170  logging.exception('Unexpected exception in handler')
6171  msg_type = TMessageType.EXCEPTION
6172  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6173  oprot.writeMessageBegin("get_result_row_for_pixel", msg_type, seqid)
6174  result.write(oprot)
6175  oprot.writeMessageEnd()
6176  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_roles (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7217 of file Heavy.py.

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

Definition at line 7607 of file Heavy.py.

7608  def process_get_runtime_function_names(self, seqid, iprot, oprot):
7610  args.read(iprot)
7611  iprot.readMessageEnd()
7613  try:
7614  result.success = self._handler.get_runtime_function_names(args.session)
7615  msg_type = TMessageType.REPLY
7616  except TTransport.TTransportException:
7617  raise
7618  except TDBException as e:
7619  msg_type = TMessageType.REPLY
7620  result.e = e
7621  except TApplicationException as ex:
7622  logging.exception('TApplication exception in handler')
7623  msg_type = TMessageType.EXCEPTION
7624  result = ex
7625  except Exception:
7626  logging.exception('Unexpected exception in handler')
7627  msg_type = TMessageType.EXCEPTION
7628  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7629  oprot.writeMessageBegin("get_runtime_function_names", msg_type, seqid)
7630  result.write(oprot)
7631  oprot.writeMessageEnd()
7632  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_runtime_table_function_names (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7529 of file Heavy.py.

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

Definition at line 5097 of file Heavy.py.

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

Definition at line 5839 of file Heavy.py.

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

Definition at line 5123 of file Heavy.py.

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

Definition at line 5305 of file Heavy.py.

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

Definition at line 5331 of file Heavy.py.

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

Definition at line 5747 of file Heavy.py.

5748  def process_get_table_epoch(self, seqid, iprot, oprot):
5749  args = get_table_epoch_args()
5750  args.read(iprot)
5751  iprot.readMessageEnd()
5752  result = get_table_epoch_result()
5753  try:
5754  result.success = self._handler.get_table_epoch(args.session, args.db_id, args.table_id)
5755  msg_type = TMessageType.REPLY
5756  except TTransport.TTransportException:
5757  raise
5758  except TApplicationException as ex:
5759  logging.exception('TApplication exception in handler')
5760  msg_type = TMessageType.EXCEPTION
5761  result = ex
5762  except Exception:
5763  logging.exception('Unexpected exception in handler')
5764  msg_type = TMessageType.EXCEPTION
5765  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5766  oprot.writeMessageBegin("get_table_epoch", msg_type, seqid)
5767  result.write(oprot)
5768  oprot.writeMessageEnd()
5769  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_epoch_by_name (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5770 of file Heavy.py.

5771  def process_get_table_epoch_by_name(self, seqid, iprot, oprot):
5773  args.read(iprot)
5774  iprot.readMessageEnd()
5776  try:
5777  result.success = self._handler.get_table_epoch_by_name(args.session, args.table_name)
5778  msg_type = TMessageType.REPLY
5779  except TTransport.TTransportException:
5780  raise
5781  except TApplicationException as ex:
5782  logging.exception('TApplication exception in handler')
5783  msg_type = TMessageType.EXCEPTION
5784  result = ex
5785  except Exception:
5786  logging.exception('Unexpected exception in handler')
5787  msg_type = TMessageType.EXCEPTION
5788  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5789  oprot.writeMessageBegin("get_table_epoch_by_name", msg_type, seqid)
5790  result.write(oprot)
5791  oprot.writeMessageEnd()
5792  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_epochs (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5793 of file Heavy.py.

5794  def process_get_table_epochs(self, seqid, iprot, oprot):
5795  args = get_table_epochs_args()
5796  args.read(iprot)
5797  iprot.readMessageEnd()
5798  result = get_table_epochs_result()
5799  try:
5800  result.success = self._handler.get_table_epochs(args.session, args.db_id, args.table_id)
5801  msg_type = TMessageType.REPLY
5802  except TTransport.TTransportException:
5803  raise
5804  except TApplicationException as ex:
5805  logging.exception('TApplication exception in handler')
5806  msg_type = TMessageType.EXCEPTION
5807  result = ex
5808  except Exception:
5809  logging.exception('Unexpected exception in handler')
5810  msg_type = TMessageType.EXCEPTION
5811  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5812  oprot.writeMessageBegin("get_table_epochs", msg_type, seqid)
5813  result.write(oprot)
5814  oprot.writeMessageEnd()
5815  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_function_details (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7555 of file Heavy.py.

7556  def process_get_table_function_details(self, seqid, iprot, oprot):
7558  args.read(iprot)
7559  iprot.readMessageEnd()
7561  try:
7562  result.success = self._handler.get_table_function_details(args.session, args.udtf_names)
7563  msg_type = TMessageType.REPLY
7564  except TTransport.TTransportException:
7565  raise
7566  except TDBException as e:
7567  msg_type = TMessageType.REPLY
7568  result.e = e
7569  except TApplicationException as ex:
7570  logging.exception('TApplication exception in handler')
7571  msg_type = TMessageType.EXCEPTION
7572  result = ex
7573  except Exception:
7574  logging.exception('Unexpected exception in handler')
7575  msg_type = TMessageType.EXCEPTION
7576  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7577  oprot.writeMessageBegin("get_table_function_details", msg_type, seqid)
7578  result.write(oprot)
7579  oprot.writeMessageEnd()
7580  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_get_table_function_names (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7503 of file Heavy.py.

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

Definition at line 5175 of file Heavy.py.

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

Definition at line 5201 of file Heavy.py.

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

Definition at line 5279 of file Heavy.py.

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

Definition at line 5409 of file Heavy.py.

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

Definition at line 5461 of file Heavy.py.

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

Definition at line 5253 of file Heavy.py.

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

Definition at line 7373 of file Heavy.py.

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

Definition at line 7347 of file Heavy.py.

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

Definition at line 6827 of file Heavy.py.

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

Definition at line 6801 of file Heavy.py.

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

Definition at line 6853 of file Heavy.py.

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

Definition at line 7165 of file Heavy.py.

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

Definition at line 7139 of file Heavy.py.

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

Definition at line 6021 of file Heavy.py.

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

Definition at line 5669 of file Heavy.py.

5670  def process_invalidate_cur_session(self, seqid, iprot, oprot):
5672  args.read(iprot)
5673  iprot.readMessageEnd()
5675  try:
5676  self._handler.invalidate_cur_session(args.parent_session, args.leaf_session, args.start_time_str, args.label, args.for_running_query_kernel)
5677  msg_type = TMessageType.REPLY
5678  except TTransport.TTransportException:
5679  raise
5680  except TDBException as e:
5681  msg_type = TMessageType.REPLY
5682  result.e = e
5683  except TApplicationException as ex:
5684  logging.exception('TApplication exception in handler')
5685  msg_type = TMessageType.EXCEPTION
5686  result = ex
5687  except Exception:
5688  logging.exception('Unexpected exception in handler')
5689  msg_type = TMessageType.EXCEPTION
5690  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5691  oprot.writeMessageBegin("invalidate_cur_session", msg_type, seqid)
5692  result.write(oprot)
5693  oprot.writeMessageEnd()
5694  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_krb5_connect (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 4993 of file Heavy.py.

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

Definition at line 6723 of file Heavy.py.

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

Definition at line 6619 of file Heavy.py.

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

Definition at line 6697 of file Heavy.py.

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

Definition at line 6645 of file Heavy.py.

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

Definition at line 6671 of file Heavy.py.

6672  def process_load_table_binary_columnar_polys(self, seqid, iprot, oprot):
6674  args.read(iprot)
6675  iprot.readMessageEnd()
6677  try:
6678  self._handler.load_table_binary_columnar_polys(args.session, args.table_name, args.cols, args.column_names, args.assign_render_groups)
6679  msg_type = TMessageType.REPLY
6680  except TTransport.TTransportException:
6681  raise
6682  except TDBException as e:
6683  msg_type = TMessageType.REPLY
6684  result.e = e
6685  except TApplicationException as ex:
6686  logging.exception('TApplication exception in handler')
6687  msg_type = TMessageType.EXCEPTION
6688  result = ex
6689  except Exception:
6690  logging.exception('Unexpected exception in handler')
6691  msg_type = TMessageType.EXCEPTION
6692  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6693  oprot.writeMessageBegin("load_table_binary_columnar_polys", msg_type, seqid)
6694  result.write(oprot)
6695  oprot.writeMessageEnd()
6696  oprot.trans.flush()
def process_load_table_binary_columnar_polys
Definition: Heavy.py:6671
def heavydb.thrift.Heavy.Processor.process_query_get_outer_fragment_count (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6957 of file Heavy.py.

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

Definition at line 7477 of file Heavy.py.

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

Definition at line 6125 of file Heavy.py.

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

Definition at line 6359 of file Heavy.py.

6360  def process_replace_dashboard(self, seqid, iprot, oprot):
6361  args = replace_dashboard_args()
6362  args.read(iprot)
6363  iprot.readMessageEnd()
6364  result = replace_dashboard_result()
6365  try:
6366  self._handler.replace_dashboard(args.session, args.dashboard_id, args.dashboard_name, args.dashboard_owner, args.dashboard_state, args.image_hash, args.dashboard_metadata)
6367  msg_type = TMessageType.REPLY
6368  except TTransport.TTransportException:
6369  raise
6370  except TDBException as e:
6371  msg_type = TMessageType.REPLY
6372  result.e = e
6373  except TApplicationException as ex:
6374  logging.exception('TApplication exception in handler')
6375  msg_type = TMessageType.EXCEPTION
6376  result = ex
6377  except Exception:
6378  logging.exception('Unexpected exception in handler')
6379  msg_type = TMessageType.EXCEPTION
6380  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6381  oprot.writeMessageBegin("replace_dashboard", msg_type, seqid)
6382  result.write(oprot)
6383  oprot.writeMessageEnd()
6384  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_cur_session (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5643 of file Heavy.py.

5644  def process_set_cur_session(self, seqid, iprot, oprot):
5645  args = set_cur_session_args()
5646  args.read(iprot)
5647  iprot.readMessageEnd()
5648  result = set_cur_session_result()
5649  try:
5650  self._handler.set_cur_session(args.parent_session, args.leaf_session, args.start_time_str, args.label, args.for_running_query_kernel)
5651  msg_type = TMessageType.REPLY
5652  except TTransport.TTransportException:
5653  raise
5654  except TDBException as e:
5655  msg_type = TMessageType.REPLY
5656  result.e = e
5657  except TApplicationException as ex:
5658  logging.exception('TApplication exception in handler')
5659  msg_type = TMessageType.EXCEPTION
5660  result = ex
5661  except Exception:
5662  logging.exception('Unexpected exception in handler')
5663  msg_type = TMessageType.EXCEPTION
5664  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5665  oprot.writeMessageBegin("set_cur_session", msg_type, seqid)
5666  result.write(oprot)
5667  oprot.writeMessageEnd()
5668  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_execution_mode (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6099 of file Heavy.py.

6100  def process_set_execution_mode(self, seqid, iprot, oprot):
6101  args = set_execution_mode_args()
6102  args.read(iprot)
6103  iprot.readMessageEnd()
6104  result = set_execution_mode_result()
6105  try:
6106  self._handler.set_execution_mode(args.session, args.mode)
6107  msg_type = TMessageType.REPLY
6108  except TTransport.TTransportException:
6109  raise
6110  except TDBException as e:
6111  msg_type = TMessageType.REPLY
6112  result.e = e
6113  except TApplicationException as ex:
6114  logging.exception('TApplication exception in handler')
6115  msg_type = TMessageType.EXCEPTION
6116  result = ex
6117  except Exception:
6118  logging.exception('Unexpected exception in handler')
6119  msg_type = TMessageType.EXCEPTION
6120  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6121  oprot.writeMessageBegin("set_execution_mode", msg_type, seqid)
6122  result.write(oprot)
6123  oprot.writeMessageEnd()
6124  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_leaf_info (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5891 of file Heavy.py.

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

Definition at line 7399 of file Heavy.py.

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

Definition at line 5695 of file Heavy.py.

5696  def process_set_table_epoch(self, seqid, iprot, oprot):
5697  args = set_table_epoch_args()
5698  args.read(iprot)
5699  iprot.readMessageEnd()
5700  result = set_table_epoch_result()
5701  try:
5702  self._handler.set_table_epoch(args.session, args.db_id, args.table_id, args.new_epoch)
5703  msg_type = TMessageType.REPLY
5704  except TTransport.TTransportException:
5705  raise
5706  except TDBException as e:
5707  msg_type = TMessageType.REPLY
5708  result.e = e
5709  except TApplicationException as ex:
5710  logging.exception('TApplication exception in handler')
5711  msg_type = TMessageType.EXCEPTION
5712  result = ex
5713  except Exception:
5714  logging.exception('Unexpected exception in handler')
5715  msg_type = TMessageType.EXCEPTION
5716  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5717  oprot.writeMessageBegin("set_table_epoch", msg_type, seqid)
5718  result.write(oprot)
5719  oprot.writeMessageEnd()
5720  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_table_epoch_by_name (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5721 of file Heavy.py.

5722  def process_set_table_epoch_by_name(self, seqid, iprot, oprot):
5724  args.read(iprot)
5725  iprot.readMessageEnd()
5727  try:
5728  self._handler.set_table_epoch_by_name(args.session, args.table_name, args.new_epoch)
5729  msg_type = TMessageType.REPLY
5730  except TTransport.TTransportException:
5731  raise
5732  except TDBException as e:
5733  msg_type = TMessageType.REPLY
5734  result.e = e
5735  except TApplicationException as ex:
5736  logging.exception('TApplication exception in handler')
5737  msg_type = TMessageType.EXCEPTION
5738  result = ex
5739  except Exception:
5740  logging.exception('Unexpected exception in handler')
5741  msg_type = TMessageType.EXCEPTION
5742  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5743  oprot.writeMessageBegin("set_table_epoch_by_name", msg_type, seqid)
5744  result.write(oprot)
5745  oprot.writeMessageEnd()
5746  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_set_table_epochs (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 5816 of file Heavy.py.

5817  def process_set_table_epochs(self, seqid, iprot, oprot):
5818  args = set_table_epochs_args()
5819  args.read(iprot)
5820  iprot.readMessageEnd()
5821  result = set_table_epochs_result()
5822  try:
5823  self._handler.set_table_epochs(args.session, args.db_id, args.table_epochs)
5824  msg_type = TMessageType.REPLY
5825  except TTransport.TTransportException:
5826  raise
5827  except TApplicationException as ex:
5828  logging.exception('TApplication exception in handler')
5829  msg_type = TMessageType.EXCEPTION
5830  result = ex
5831  except Exception:
5832  logging.exception('Unexpected exception in handler')
5833  msg_type = TMessageType.EXCEPTION
5834  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5835  oprot.writeMessageBegin("set_table_epochs", msg_type, seqid)
5836  result.write(oprot)
5837  oprot.writeMessageEnd()
5838  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_share_dashboard (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6463 of file Heavy.py.

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

Definition at line 6411 of file Heavy.py.

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

Definition at line 5917 of file Heavy.py.

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

Definition at line 5943 of file Heavy.py.

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

Definition at line 5969 of file Heavy.py.

5970  def process_sql_execute_gdf(self, seqid, iprot, oprot):
5971  args = sql_execute_gdf_args()
5972  args.read(iprot)
5973  iprot.readMessageEnd()
5974  result = sql_execute_gdf_result()
5975  try:
5976  result.success = self._handler.sql_execute_gdf(args.session, args.query, args.device_id, args.first_n)
5977  msg_type = TMessageType.REPLY
5978  except TTransport.TTransportException:
5979  raise
5980  except TDBException as e:
5981  msg_type = TMessageType.REPLY
5982  result.e = e
5983  except TApplicationException as ex:
5984  logging.exception('TApplication exception in handler')
5985  msg_type = TMessageType.EXCEPTION
5986  result = ex
5987  except Exception:
5988  logging.exception('Unexpected exception in handler')
5989  msg_type = TMessageType.EXCEPTION
5990  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
5991  oprot.writeMessageBegin("sql_execute_gdf", msg_type, seqid)
5992  result.write(oprot)
5993  oprot.writeMessageEnd()
5994  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_sql_validate (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 6047 of file Heavy.py.

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

Definition at line 5487 of file Heavy.py.

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

Definition at line 7009 of file Heavy.py.

7010  def process_start_query(self, seqid, iprot, oprot):
7011  args = start_query_args()
7012  args.read(iprot)
7013  iprot.readMessageEnd()
7014  result = start_query_result()
7015  try:
7016  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)
7017  msg_type = TMessageType.REPLY
7018  except TTransport.TTransportException:
7019  raise
7020  except TDBException as e:
7021  msg_type = TMessageType.REPLY
7022  result.e = e
7023  except TApplicationException as ex:
7024  logging.exception('TApplication exception in handler')
7025  msg_type = TMessageType.EXCEPTION
7026  result = ex
7027  except Exception:
7028  logging.exception('Unexpected exception in handler')
7029  msg_type = TMessageType.EXCEPTION
7030  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
7031  oprot.writeMessageBegin("start_query", msg_type, seqid)
7032  result.write(oprot)
7033  oprot.writeMessageEnd()
7034  oprot.trans.flush()
def heavydb.thrift.Heavy.Processor.process_start_render_query (   self,
  seqid,
  iprot,
  oprot 
)

Definition at line 7087 of file Heavy.py.

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

Definition at line 5513 of file Heavy.py.

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

Definition at line 5045 of file Heavy.py.

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

Definition at line 6489 of file Heavy.py.

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

Definition at line 6515 of file Heavy.py.

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

Definition at line 6229 of file Heavy.py.

6230  def process_update_custom_expression(self, seqid, iprot, oprot):
6232  args.read(iprot)
6233  iprot.readMessageEnd()
6235  try:
6236  self._handler.update_custom_expression(args.session, args.id, args.expression_json)
6237  msg_type = TMessageType.REPLY
6238  except TTransport.TTransportException:
6239  raise
6240  except TDBException as e:
6241  msg_type = TMessageType.REPLY
6242  result.e = e
6243  except TApplicationException as ex:
6244  logging.exception('TApplication exception in handler')
6245  msg_type = TMessageType.EXCEPTION
6246  result = ex
6247  except Exception:
6248  logging.exception('Unexpected exception in handler')
6249  msg_type = TMessageType.EXCEPTION
6250  result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
6251  oprot.writeMessageBegin("update_custom_expression", msg_type, seqid)
6252  result.write(oprot)
6253  oprot.writeMessageEnd()
6254  oprot.trans.flush()

Member Data Documentation

heavydb.thrift.Heavy.Processor._handler
private

Definition at line 4839 of file Heavy.py.

heavydb.thrift.Heavy.Processor._on_message_begin
private

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

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


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