OmniSci.py

Go to the documentation of this file.

#
# Autogenerated by Thrift Compiler (0.13.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py
#

from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
from thrift.protocol.TProtocol import TProtocolException
from thrift.TRecursive import fix_spec

import sys
import logging
from .ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport
all_structs = []


class Iface(object):
    def connect(self, user, passwd, dbname):
        """
        Parameters:
         - user
         - passwd
         - dbname

        """
        pass

    def krb5_connect(self, inputToken, dbname):
        """
        Parameters:
         - inputToken
         - dbname

        """
        pass

    def disconnect(self, session):
        """
        Parameters:
         - session

        """
        pass

    def switch_database(self, session, dbname):
        """
        Parameters:
         - session
         - dbname

        """
        pass

    def clone_session(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_server_status(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_status(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_hardware_info(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_tables(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_physical_tables(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_views(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_tables_meta(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_table_details(self, session, table_name):
        """
        Parameters:
         - session
         - table_name

        """
        pass

    def get_internal_table_details(self, session, table_name):
        """
        Parameters:
         - session
         - table_name

        """
        pass

    def get_users(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_databases(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_version(self):
        pass

    def start_heap_profile(self, session):
        """
        Parameters:
         - session

        """
        pass

    def stop_heap_profile(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_heap_profile(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_memory(self, session, memory_level):
        """
        Parameters:
         - session
         - memory_level

        """
        pass

    def clear_cpu_memory(self, session):
        """
        Parameters:
         - session

        """
        pass

    def clear_gpu_memory(self, session):
        """
        Parameters:
         - session

        """
        pass

    def set_table_epoch(self, session, db_id, table_id, new_epoch):
        """
        Parameters:
         - session
         - db_id
         - table_id
         - new_epoch

        """
        pass

    def set_table_epoch_by_name(self, session, table_name, new_epoch):
        """
        Parameters:
         - session
         - table_name
         - new_epoch

        """
        pass

    def get_table_epoch(self, session, db_id, table_id):
        """
        Parameters:
         - session
         - db_id
         - table_id

        """
        pass

    def get_table_epoch_by_name(self, session, table_name):
        """
        Parameters:
         - session
         - table_name

        """
        pass

    def get_session_info(self, session):
        """
        Parameters:
         - session

        """
        pass

    def sql_execute(self, session, query, column_format, nonce, first_n, at_most_n):
        """
        Parameters:
         - session
         - query
         - column_format
         - nonce
         - first_n
         - at_most_n

        """
        pass

    def sql_execute_df(self, session, query, device_type, device_id, first_n, transport_method):
        """
        Parameters:
         - session
         - query
         - device_type
         - device_id
         - first_n
         - transport_method

        """
        pass

    def sql_execute_gdf(self, session, query, device_id, first_n):
        """
        Parameters:
         - session
         - query
         - device_id
         - first_n

        """
        pass

    def deallocate_df(self, session, df, device_type, device_id):
        """
        Parameters:
         - session
         - df
         - device_type
         - device_id

        """
        pass

    def interrupt(self, query_session, interrupt_session):
        """
        Parameters:
         - query_session
         - interrupt_session

        """
        pass

    def sql_validate(self, session, query):
        """
        Parameters:
         - session
         - query

        """
        pass

    def get_completion_hints(self, session, sql, cursor):
        """
        Parameters:
         - session
         - sql
         - cursor

        """
        pass

    def set_execution_mode(self, session, mode):
        """
        Parameters:
         - session
         - mode

        """
        pass

    def render_vega(self, session, widget_id, vega_json, compression_level, nonce):
        """
        Parameters:
         - session
         - widget_id
         - vega_json
         - compression_level
         - nonce

        """
        pass

    def get_result_row_for_pixel(self, session, widget_id, pixel, table_col_names, column_format, pixelRadius, nonce):
        """
        Parameters:
         - session
         - widget_id
         - pixel
         - table_col_names
         - column_format
         - pixelRadius
         - nonce

        """
        pass

    def get_dashboard(self, session, dashboard_id):
        """
        Parameters:
         - session
         - dashboard_id

        """
        pass

    def get_dashboards(self, session):
        """
        Parameters:
         - session

        """
        pass

    def create_dashboard(self, session, dashboard_name, dashboard_state, image_hash, dashboard_metadata):
        """
        Parameters:
         - session
         - dashboard_name
         - dashboard_state
         - image_hash
         - dashboard_metadata

        """
        pass

    def replace_dashboard(self, session, dashboard_id, dashboard_name, dashboard_owner, dashboard_state, image_hash, dashboard_metadata):
        """
        Parameters:
         - session
         - dashboard_id
         - dashboard_name
         - dashboard_owner
         - dashboard_state
         - image_hash
         - dashboard_metadata

        """
        pass

    def delete_dashboard(self, session, dashboard_id):
        """
        Parameters:
         - session
         - dashboard_id

        """
        pass

    def share_dashboards(self, session, dashboard_ids, groups, permissions):
        """
        Parameters:
         - session
         - dashboard_ids
         - groups
         - permissions

        """
        pass

    def delete_dashboards(self, session, dashboard_ids):
        """
        Parameters:
         - session
         - dashboard_ids

        """
        pass

    def share_dashboard(self, session, dashboard_id, groups, objects, permissions, grant_role):
        """
        Parameters:
         - session
         - dashboard_id
         - groups
         - objects
         - permissions
         - grant_role

        """
        pass

    def unshare_dashboard(self, session, dashboard_id, groups, objects, permissions):
        """
        Parameters:
         - session
         - dashboard_id
         - groups
         - objects
         - permissions

        """
        pass

    def unshare_dashboards(self, session, dashboard_ids, groups, permissions):
        """
        Parameters:
         - session
         - dashboard_ids
         - groups
         - permissions

        """
        pass

    def get_dashboard_grantees(self, session, dashboard_id):
        """
        Parameters:
         - session
         - dashboard_id

        """
        pass

    def get_link_view(self, session, link):
        """
        Parameters:
         - session
         - link

        """
        pass

    def create_link(self, session, view_state, view_metadata):
        """
        Parameters:
         - session
         - view_state
         - view_metadata

        """
        pass

    def load_table_binary(self, session, table_name, rows):
        """
        Parameters:
         - session
         - table_name
         - rows

        """
        pass

    def load_table_binary_columnar(self, session, table_name, cols):
        """
        Parameters:
         - session
         - table_name
         - cols

        """
        pass

    def load_table_binary_arrow(self, session, table_name, arrow_stream):
        """
        Parameters:
         - session
         - table_name
         - arrow_stream

        """
        pass

    def load_table(self, session, table_name, rows):
        """
        Parameters:
         - session
         - table_name
         - rows

        """
        pass

    def detect_column_types(self, session, file_name, copy_params):
        """
        Parameters:
         - session
         - file_name
         - copy_params

        """
        pass

    def create_table(self, session, table_name, row_desc, file_type, create_params):
        """
        Parameters:
         - session
         - table_name
         - row_desc
         - file_type
         - create_params

        """
        pass

    def import_table(self, session, table_name, file_name, copy_params):
        """
        Parameters:
         - session
         - table_name
         - file_name
         - copy_params

        """
        pass

    def import_geo_table(self, session, table_name, file_name, copy_params, row_desc, create_params):
        """
        Parameters:
         - session
         - table_name
         - file_name
         - copy_params
         - row_desc
         - create_params

        """
        pass

    def import_table_status(self, session, import_id):
        """
        Parameters:
         - session
         - import_id

        """
        pass

    def get_first_geo_file_in_archive(self, session, archive_path, copy_params):
        """
        Parameters:
         - session
         - archive_path
         - copy_params

        """
        pass

    def get_all_files_in_archive(self, session, archive_path, copy_params):
        """
        Parameters:
         - session
         - archive_path
         - copy_params

        """
        pass

    def get_layers_in_geo_file(self, session, file_name, copy_params):
        """
        Parameters:
         - session
         - file_name
         - copy_params

        """
        pass

    def query_get_outer_fragment_count(self, session, query):
        """
        Parameters:
         - session
         - query

        """
        pass

    def check_table_consistency(self, session, table_id):
        """
        Parameters:
         - session
         - table_id

        """
        pass

    def start_query(self, leaf_session, parent_session, query_ra, just_explain, outer_fragment_indices):
        """
        Parameters:
         - leaf_session
         - parent_session
         - query_ra
         - just_explain
         - outer_fragment_indices

        """
        pass

    def execute_query_step(self, pending_query):
        """
        Parameters:
         - pending_query

        """
        pass

    def broadcast_serialized_rows(self, serialized_rows, row_desc, query_id):
        """
        Parameters:
         - serialized_rows
         - row_desc
         - query_id

        """
        pass

    def start_render_query(self, session, widget_id, node_idx, vega_json):
        """
        Parameters:
         - session
         - widget_id
         - node_idx
         - vega_json

        """
        pass

    def execute_next_render_step(self, pending_render, merged_data):
        """
        Parameters:
         - pending_render
         - merged_data

        """
        pass

    def insert_data(self, session, insert_data):
        """
        Parameters:
         - session
         - insert_data

        """
        pass

    def checkpoint(self, session, db_id, table_id):
        """
        Parameters:
         - session
         - db_id
         - table_id

        """
        pass

    def get_roles(self, session):
        """
        Parameters:
         - session

        """
        pass

    def get_db_objects_for_grantee(self, session, roleName):
        """
        Parameters:
         - session
         - roleName

        """
        pass

    def get_db_object_privs(self, session, objectName, type):
        """
        Parameters:
         - session
         - objectName
         - type

        """
        pass

    def get_all_roles_for_user(self, session, userName):
        """
        Parameters:
         - session
         - userName

        """
        pass

    def has_role(self, session, granteeName, roleName):
        """
        Parameters:
         - session
         - granteeName
         - roleName

        """
        pass

    def has_object_privilege(self, session, granteeName, ObjectName, objectType, permissions):
        """
        Parameters:
         - session
         - granteeName
         - ObjectName
         - objectType
         - permissions

        """
        pass

    def set_license_key(self, session, key, nonce):
        """
        Parameters:
         - session
         - key
         - nonce

        """
        pass

    def get_license_claims(self, session, nonce):
        """
        Parameters:
         - session
         - nonce

        """
        pass

    def get_device_parameters(self, session):
        """
        Parameters:
         - session

        """
        pass

    def register_runtime_extension_functions(self, session, udfs, udtfs, device_ir_map):
        """
        Parameters:
         - session
         - udfs
         - udtfs
         - device_ir_map

        """
        pass


class Client(Iface):
    def __init__(self, iprot, oprot=None):
        self._iprot = self._oprot = iprot
        if oprot is not None:
            self._oprot = oprot
        self._seqid = 0

    def connect(self, user, passwd, dbname):
        """
        Parameters:
         - user
         - passwd
         - dbname

        """
        self.send_connect(user, passwd, dbname)
        return self.recv_connect()

    def send_connect(self, user, passwd, dbname):
        self._oprot.writeMessageBegin('connect', TMessageType.CALL, self._seqid)
        args = connect_args()
        args.user = user
        args.passwd = passwd
        args.dbname = dbname
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_connect(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = connect_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "connect failed: unknown result")

    def krb5_connect(self, inputToken, dbname):
        """
        Parameters:
         - inputToken
         - dbname

        """
        self.send_krb5_connect(inputToken, dbname)
        return self.recv_krb5_connect()

    def send_krb5_connect(self, inputToken, dbname):
        self._oprot.writeMessageBegin('krb5_connect', TMessageType.CALL, self._seqid)
        args = krb5_connect_args()
        args.inputToken = inputToken
        args.dbname = dbname
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_krb5_connect(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = krb5_connect_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "krb5_connect failed: unknown result")

    def disconnect(self, session):
        """
        Parameters:
         - session

        """
        self.send_disconnect(session)
        self.recv_disconnect()

    def send_disconnect(self, session):
        self._oprot.writeMessageBegin('disconnect', TMessageType.CALL, self._seqid)
        args = disconnect_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_disconnect(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = disconnect_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def switch_database(self, session, dbname):
        """
        Parameters:
         - session
         - dbname

        """
        self.send_switch_database(session, dbname)
        self.recv_switch_database()

    def send_switch_database(self, session, dbname):
        self._oprot.writeMessageBegin('switch_database', TMessageType.CALL, self._seqid)
        args = switch_database_args()
        args.session = session
        args.dbname = dbname
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_switch_database(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = switch_database_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def clone_session(self, session):
        """
        Parameters:
         - session

        """
        self.send_clone_session(session)
        return self.recv_clone_session()

    def send_clone_session(self, session):
        self._oprot.writeMessageBegin('clone_session', TMessageType.CALL, self._seqid)
        args = clone_session_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_clone_session(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = clone_session_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "clone_session failed: unknown result")

    def get_server_status(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_server_status(session)
        return self.recv_get_server_status()

    def send_get_server_status(self, session):
        self._oprot.writeMessageBegin('get_server_status', TMessageType.CALL, self._seqid)
        args = get_server_status_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_server_status(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_server_status_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_server_status failed: unknown result")

    def get_status(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_status(session)
        return self.recv_get_status()

    def send_get_status(self, session):
        self._oprot.writeMessageBegin('get_status', TMessageType.CALL, self._seqid)
        args = get_status_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_status(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_status_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_status failed: unknown result")

    def get_hardware_info(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_hardware_info(session)
        return self.recv_get_hardware_info()

    def send_get_hardware_info(self, session):
        self._oprot.writeMessageBegin('get_hardware_info', TMessageType.CALL, self._seqid)
        args = get_hardware_info_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_hardware_info(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_hardware_info_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_hardware_info failed: unknown result")

    def get_tables(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_tables(session)
        return self.recv_get_tables()

    def send_get_tables(self, session):
        self._oprot.writeMessageBegin('get_tables', TMessageType.CALL, self._seqid)
        args = get_tables_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_tables(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_tables_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_tables failed: unknown result")

    def get_physical_tables(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_physical_tables(session)
        return self.recv_get_physical_tables()

    def send_get_physical_tables(self, session):
        self._oprot.writeMessageBegin('get_physical_tables', TMessageType.CALL, self._seqid)
        args = get_physical_tables_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_physical_tables(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_physical_tables_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_physical_tables failed: unknown result")

    def get_views(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_views(session)
        return self.recv_get_views()

    def send_get_views(self, session):
        self._oprot.writeMessageBegin('get_views', TMessageType.CALL, self._seqid)
        args = get_views_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_views(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_views_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_views failed: unknown result")

    def get_tables_meta(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_tables_meta(session)
        return self.recv_get_tables_meta()

    def send_get_tables_meta(self, session):
        self._oprot.writeMessageBegin('get_tables_meta', TMessageType.CALL, self._seqid)
        args = get_tables_meta_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_tables_meta(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_tables_meta_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_tables_meta failed: unknown result")

    def get_table_details(self, session, table_name):
        """
        Parameters:
         - session
         - table_name

        """
        self.send_get_table_details(session, table_name)
        return self.recv_get_table_details()

    def send_get_table_details(self, session, table_name):
        self._oprot.writeMessageBegin('get_table_details', TMessageType.CALL, self._seqid)
        args = get_table_details_args()
        args.session = session
        args.table_name = table_name
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_table_details(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_table_details_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_table_details failed: unknown result")

    def get_internal_table_details(self, session, table_name):
        """
        Parameters:
         - session
         - table_name

        """
        self.send_get_internal_table_details(session, table_name)
        return self.recv_get_internal_table_details()

    def send_get_internal_table_details(self, session, table_name):
        self._oprot.writeMessageBegin('get_internal_table_details', TMessageType.CALL, self._seqid)
        args = get_internal_table_details_args()
        args.session = session
        args.table_name = table_name
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_internal_table_details(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_internal_table_details_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_internal_table_details failed: unknown result")

    def get_users(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_users(session)
        return self.recv_get_users()

    def send_get_users(self, session):
        self._oprot.writeMessageBegin('get_users', TMessageType.CALL, self._seqid)
        args = get_users_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_users(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_users_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_users failed: unknown result")

    def get_databases(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_databases(session)
        return self.recv_get_databases()

    def send_get_databases(self, session):
        self._oprot.writeMessageBegin('get_databases', TMessageType.CALL, self._seqid)
        args = get_databases_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_databases(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_databases_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_databases failed: unknown result")

    def get_version(self):
        self.send_get_version()
        return self.recv_get_version()

    def send_get_version(self):
        self._oprot.writeMessageBegin('get_version', TMessageType.CALL, self._seqid)
        args = get_version_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_version(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_version_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_version failed: unknown result")

    def start_heap_profile(self, session):
        """
        Parameters:
         - session

        """
        self.send_start_heap_profile(session)
        self.recv_start_heap_profile()

    def send_start_heap_profile(self, session):
        self._oprot.writeMessageBegin('start_heap_profile', TMessageType.CALL, self._seqid)
        args = start_heap_profile_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_start_heap_profile(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = start_heap_profile_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def stop_heap_profile(self, session):
        """
        Parameters:
         - session

        """
        self.send_stop_heap_profile(session)
        self.recv_stop_heap_profile()

    def send_stop_heap_profile(self, session):
        self._oprot.writeMessageBegin('stop_heap_profile', TMessageType.CALL, self._seqid)
        args = stop_heap_profile_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_stop_heap_profile(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = stop_heap_profile_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def get_heap_profile(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_heap_profile(session)
        return self.recv_get_heap_profile()

    def send_get_heap_profile(self, session):
        self._oprot.writeMessageBegin('get_heap_profile', TMessageType.CALL, self._seqid)
        args = get_heap_profile_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_heap_profile(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_heap_profile_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_heap_profile failed: unknown result")

    def get_memory(self, session, memory_level):
        """
        Parameters:
         - session
         - memory_level

        """
        self.send_get_memory(session, memory_level)
        return self.recv_get_memory()

    def send_get_memory(self, session, memory_level):
        self._oprot.writeMessageBegin('get_memory', TMessageType.CALL, self._seqid)
        args = get_memory_args()
        args.session = session
        args.memory_level = memory_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_memory(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_memory_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_memory failed: unknown result")

    def clear_cpu_memory(self, session):
        """
        Parameters:
         - session

        """
        self.send_clear_cpu_memory(session)
        self.recv_clear_cpu_memory()

    def send_clear_cpu_memory(self, session):
        self._oprot.writeMessageBegin('clear_cpu_memory', TMessageType.CALL, self._seqid)
        args = clear_cpu_memory_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_clear_cpu_memory(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = clear_cpu_memory_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def clear_gpu_memory(self, session):
        """
        Parameters:
         - session

        """
        self.send_clear_gpu_memory(session)
        self.recv_clear_gpu_memory()

    def send_clear_gpu_memory(self, session):
        self._oprot.writeMessageBegin('clear_gpu_memory', TMessageType.CALL, self._seqid)
        args = clear_gpu_memory_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_clear_gpu_memory(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = clear_gpu_memory_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def set_table_epoch(self, session, db_id, table_id, new_epoch):
        """
        Parameters:
         - session
         - db_id
         - table_id
         - new_epoch

        """
        self.send_set_table_epoch(session, db_id, table_id, new_epoch)
        self.recv_set_table_epoch()

    def send_set_table_epoch(self, session, db_id, table_id, new_epoch):
        self._oprot.writeMessageBegin('set_table_epoch', TMessageType.CALL, self._seqid)
        args = set_table_epoch_args()
        args.session = session
        args.db_id = db_id
        args.table_id = table_id
        args.new_epoch = new_epoch
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_set_table_epoch(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = set_table_epoch_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def set_table_epoch_by_name(self, session, table_name, new_epoch):
        """
        Parameters:
         - session
         - table_name
         - new_epoch

        """
        self.send_set_table_epoch_by_name(session, table_name, new_epoch)
        self.recv_set_table_epoch_by_name()

    def send_set_table_epoch_by_name(self, session, table_name, new_epoch):
        self._oprot.writeMessageBegin('set_table_epoch_by_name', TMessageType.CALL, self._seqid)
        args = set_table_epoch_by_name_args()
        args.session = session
        args.table_name = table_name
        args.new_epoch = new_epoch
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_set_table_epoch_by_name(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = set_table_epoch_by_name_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def get_table_epoch(self, session, db_id, table_id):
        """
        Parameters:
         - session
         - db_id
         - table_id

        """
        self.send_get_table_epoch(session, db_id, table_id)
        return self.recv_get_table_epoch()

    def send_get_table_epoch(self, session, db_id, table_id):
        self._oprot.writeMessageBegin('get_table_epoch', TMessageType.CALL, self._seqid)
        args = get_table_epoch_args()
        args.session = session
        args.db_id = db_id
        args.table_id = table_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_table_epoch(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_table_epoch_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_table_epoch failed: unknown result")

    def get_table_epoch_by_name(self, session, table_name):
        """
        Parameters:
         - session
         - table_name

        """
        self.send_get_table_epoch_by_name(session, table_name)
        return self.recv_get_table_epoch_by_name()

    def send_get_table_epoch_by_name(self, session, table_name):
        self._oprot.writeMessageBegin('get_table_epoch_by_name', TMessageType.CALL, self._seqid)
        args = get_table_epoch_by_name_args()
        args.session = session
        args.table_name = table_name
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_table_epoch_by_name(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_table_epoch_by_name_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_table_epoch_by_name failed: unknown result")

    def get_session_info(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_session_info(session)
        return self.recv_get_session_info()

    def send_get_session_info(self, session):
        self._oprot.writeMessageBegin('get_session_info', TMessageType.CALL, self._seqid)
        args = get_session_info_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_session_info(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_session_info_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_session_info failed: unknown result")

    def sql_execute(self, session, query, column_format, nonce, first_n, at_most_n):
        """
        Parameters:
         - session
         - query
         - column_format
         - nonce
         - first_n
         - at_most_n

        """
        self.send_sql_execute(session, query, column_format, nonce, first_n, at_most_n)
        return self.recv_sql_execute()

    def send_sql_execute(self, session, query, column_format, nonce, first_n, at_most_n):
        self._oprot.writeMessageBegin('sql_execute', TMessageType.CALL, self._seqid)
        args = sql_execute_args()
        args.session = session
        args.query = query
        args.column_format = column_format
        args.nonce = nonce
        args.first_n = first_n
        args.at_most_n = at_most_n
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_sql_execute(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = sql_execute_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "sql_execute failed: unknown result")

    def sql_execute_df(self, session, query, device_type, device_id, first_n, transport_method):
        """
        Parameters:
         - session
         - query
         - device_type
         - device_id
         - first_n
         - transport_method

        """
        self.send_sql_execute_df(session, query, device_type, device_id, first_n, transport_method)
        return self.recv_sql_execute_df()

    def send_sql_execute_df(self, session, query, device_type, device_id, first_n, transport_method):
        self._oprot.writeMessageBegin('sql_execute_df', TMessageType.CALL, self._seqid)
        args = sql_execute_df_args()
        args.session = session
        args.query = query
        args.device_type = device_type
        args.device_id = device_id
        args.first_n = first_n
        args.transport_method = transport_method
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_sql_execute_df(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = sql_execute_df_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "sql_execute_df failed: unknown result")

    def sql_execute_gdf(self, session, query, device_id, first_n):
        """
        Parameters:
         - session
         - query
         - device_id
         - first_n

        """
        self.send_sql_execute_gdf(session, query, device_id, first_n)
        return self.recv_sql_execute_gdf()

    def send_sql_execute_gdf(self, session, query, device_id, first_n):
        self._oprot.writeMessageBegin('sql_execute_gdf', TMessageType.CALL, self._seqid)
        args = sql_execute_gdf_args()
        args.session = session
        args.query = query
        args.device_id = device_id
        args.first_n = first_n
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_sql_execute_gdf(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = sql_execute_gdf_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "sql_execute_gdf failed: unknown result")

    def deallocate_df(self, session, df, device_type, device_id):
        """
        Parameters:
         - session
         - df
         - device_type
         - device_id

        """
        self.send_deallocate_df(session, df, device_type, device_id)
        self.recv_deallocate_df()

    def send_deallocate_df(self, session, df, device_type, device_id):
        self._oprot.writeMessageBegin('deallocate_df', TMessageType.CALL, self._seqid)
        args = deallocate_df_args()
        args.session = session
        args.df = df
        args.device_type = device_type
        args.device_id = device_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_deallocate_df(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = deallocate_df_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def interrupt(self, query_session, interrupt_session):
        """
        Parameters:
         - query_session
         - interrupt_session

        """
        self.send_interrupt(query_session, interrupt_session)
        self.recv_interrupt()

    def send_interrupt(self, query_session, interrupt_session):
        self._oprot.writeMessageBegin('interrupt', TMessageType.CALL, self._seqid)
        args = interrupt_args()
        args.query_session = query_session
        args.interrupt_session = interrupt_session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_interrupt(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = interrupt_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def sql_validate(self, session, query):
        """
        Parameters:
         - session
         - query

        """
        self.send_sql_validate(session, query)
        return self.recv_sql_validate()

    def send_sql_validate(self, session, query):
        self._oprot.writeMessageBegin('sql_validate', TMessageType.CALL, self._seqid)
        args = sql_validate_args()
        args.session = session
        args.query = query
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_sql_validate(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = sql_validate_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "sql_validate failed: unknown result")

    def get_completion_hints(self, session, sql, cursor):
        """
        Parameters:
         - session
         - sql
         - cursor

        """
        self.send_get_completion_hints(session, sql, cursor)
        return self.recv_get_completion_hints()

    def send_get_completion_hints(self, session, sql, cursor):
        self._oprot.writeMessageBegin('get_completion_hints', TMessageType.CALL, self._seqid)
        args = get_completion_hints_args()
        args.session = session
        args.sql = sql
        args.cursor = cursor
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_completion_hints(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_completion_hints_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_completion_hints failed: unknown result")

    def set_execution_mode(self, session, mode):
        """
        Parameters:
         - session
         - mode

        """
        self.send_set_execution_mode(session, mode)
        self.recv_set_execution_mode()

    def send_set_execution_mode(self, session, mode):
        self._oprot.writeMessageBegin('set_execution_mode', TMessageType.CALL, self._seqid)
        args = set_execution_mode_args()
        args.session = session
        args.mode = mode
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_set_execution_mode(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = set_execution_mode_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def render_vega(self, session, widget_id, vega_json, compression_level, nonce):
        """
        Parameters:
         - session
         - widget_id
         - vega_json
         - compression_level
         - nonce

        """
        self.send_render_vega(session, widget_id, vega_json, compression_level, nonce)
        return self.recv_render_vega()

    def send_render_vega(self, session, widget_id, vega_json, compression_level, nonce):
        self._oprot.writeMessageBegin('render_vega', TMessageType.CALL, self._seqid)
        args = render_vega_args()
        args.session = session
        args.widget_id = widget_id
        args.vega_json = vega_json
        args.compression_level = compression_level
        args.nonce = nonce
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_render_vega(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = render_vega_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "render_vega failed: unknown result")

    def get_result_row_for_pixel(self, session, widget_id, pixel, table_col_names, column_format, pixelRadius, nonce):
        """
        Parameters:
         - session
         - widget_id
         - pixel
         - table_col_names
         - column_format
         - pixelRadius
         - nonce

        """
        self.send_get_result_row_for_pixel(session, widget_id, pixel, table_col_names, column_format, pixelRadius, nonce)
        return self.recv_get_result_row_for_pixel()

    def send_get_result_row_for_pixel(self, session, widget_id, pixel, table_col_names, column_format, pixelRadius, nonce):
        self._oprot.writeMessageBegin('get_result_row_for_pixel', TMessageType.CALL, self._seqid)
        args = get_result_row_for_pixel_args()
        args.session = session
        args.widget_id = widget_id
        args.pixel = pixel
        args.table_col_names = table_col_names
        args.column_format = column_format
        args.pixelRadius = pixelRadius
        args.nonce = nonce
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_result_row_for_pixel(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_result_row_for_pixel_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_result_row_for_pixel failed: unknown result")

    def get_dashboard(self, session, dashboard_id):
        """
        Parameters:
         - session
         - dashboard_id

        """
        self.send_get_dashboard(session, dashboard_id)
        return self.recv_get_dashboard()

    def send_get_dashboard(self, session, dashboard_id):
        self._oprot.writeMessageBegin('get_dashboard', TMessageType.CALL, self._seqid)
        args = get_dashboard_args()
        args.session = session
        args.dashboard_id = dashboard_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_dashboard(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_dashboard_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_dashboard failed: unknown result")

    def get_dashboards(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_dashboards(session)
        return self.recv_get_dashboards()

    def send_get_dashboards(self, session):
        self._oprot.writeMessageBegin('get_dashboards', TMessageType.CALL, self._seqid)
        args = get_dashboards_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_dashboards(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_dashboards_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_dashboards failed: unknown result")

    def create_dashboard(self, session, dashboard_name, dashboard_state, image_hash, dashboard_metadata):
        """
        Parameters:
         - session
         - dashboard_name
         - dashboard_state
         - image_hash
         - dashboard_metadata

        """
        self.send_create_dashboard(session, dashboard_name, dashboard_state, image_hash, dashboard_metadata)
        return self.recv_create_dashboard()

    def send_create_dashboard(self, session, dashboard_name, dashboard_state, image_hash, dashboard_metadata):
        self._oprot.writeMessageBegin('create_dashboard', TMessageType.CALL, self._seqid)
        args = create_dashboard_args()
        args.session = session
        args.dashboard_name = dashboard_name
        args.dashboard_state = dashboard_state
        args.image_hash = image_hash
        args.dashboard_metadata = dashboard_metadata
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_create_dashboard(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = create_dashboard_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "create_dashboard failed: unknown result")

    def replace_dashboard(self, session, dashboard_id, dashboard_name, dashboard_owner, dashboard_state, image_hash, dashboard_metadata):
        """
        Parameters:
         - session
         - dashboard_id
         - dashboard_name
         - dashboard_owner
         - dashboard_state
         - image_hash
         - dashboard_metadata

        """
        self.send_replace_dashboard(session, dashboard_id, dashboard_name, dashboard_owner, dashboard_state, image_hash, dashboard_metadata)
        self.recv_replace_dashboard()

    def send_replace_dashboard(self, session, dashboard_id, dashboard_name, dashboard_owner, dashboard_state, image_hash, dashboard_metadata):
        self._oprot.writeMessageBegin('replace_dashboard', TMessageType.CALL, self._seqid)
        args = replace_dashboard_args()
        args.session = session
        args.dashboard_id = dashboard_id
        args.dashboard_name = dashboard_name
        args.dashboard_owner = dashboard_owner
        args.dashboard_state = dashboard_state
        args.image_hash = image_hash
        args.dashboard_metadata = dashboard_metadata
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_replace_dashboard(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = replace_dashboard_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def delete_dashboard(self, session, dashboard_id):
        """
        Parameters:
         - session
         - dashboard_id

        """
        self.send_delete_dashboard(session, dashboard_id)
        self.recv_delete_dashboard()

    def send_delete_dashboard(self, session, dashboard_id):
        self._oprot.writeMessageBegin('delete_dashboard', TMessageType.CALL, self._seqid)
        args = delete_dashboard_args()
        args.session = session
        args.dashboard_id = dashboard_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_delete_dashboard(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = delete_dashboard_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def share_dashboards(self, session, dashboard_ids, groups, permissions):
        """
        Parameters:
         - session
         - dashboard_ids
         - groups
         - permissions

        """
        self.send_share_dashboards(session, dashboard_ids, groups, permissions)
        self.recv_share_dashboards()

    def send_share_dashboards(self, session, dashboard_ids, groups, permissions):
        self._oprot.writeMessageBegin('share_dashboards', TMessageType.CALL, self._seqid)
        args = share_dashboards_args()
        args.session = session
        args.dashboard_ids = dashboard_ids
        args.groups = groups
        args.permissions = permissions
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_share_dashboards(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = share_dashboards_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def delete_dashboards(self, session, dashboard_ids):
        """
        Parameters:
         - session
         - dashboard_ids

        """
        self.send_delete_dashboards(session, dashboard_ids)
        self.recv_delete_dashboards()

    def send_delete_dashboards(self, session, dashboard_ids):
        self._oprot.writeMessageBegin('delete_dashboards', TMessageType.CALL, self._seqid)
        args = delete_dashboards_args()
        args.session = session
        args.dashboard_ids = dashboard_ids
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_delete_dashboards(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = delete_dashboards_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def share_dashboard(self, session, dashboard_id, groups, objects, permissions, grant_role):
        """
        Parameters:
         - session
         - dashboard_id
         - groups
         - objects
         - permissions
         - grant_role

        """
        self.send_share_dashboard(session, dashboard_id, groups, objects, permissions, grant_role)
        self.recv_share_dashboard()

    def send_share_dashboard(self, session, dashboard_id, groups, objects, permissions, grant_role):
        self._oprot.writeMessageBegin('share_dashboard', TMessageType.CALL, self._seqid)
        args = share_dashboard_args()
        args.session = session
        args.dashboard_id = dashboard_id
        args.groups = groups
        args.objects = objects
        args.permissions = permissions
        args.grant_role = grant_role
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_share_dashboard(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = share_dashboard_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def unshare_dashboard(self, session, dashboard_id, groups, objects, permissions):
        """
        Parameters:
         - session
         - dashboard_id
         - groups
         - objects
         - permissions

        """
        self.send_unshare_dashboard(session, dashboard_id, groups, objects, permissions)
        self.recv_unshare_dashboard()

    def send_unshare_dashboard(self, session, dashboard_id, groups, objects, permissions):
        self._oprot.writeMessageBegin('unshare_dashboard', TMessageType.CALL, self._seqid)
        args = unshare_dashboard_args()
        args.session = session
        args.dashboard_id = dashboard_id
        args.groups = groups
        args.objects = objects
        args.permissions = permissions
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_unshare_dashboard(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = unshare_dashboard_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def unshare_dashboards(self, session, dashboard_ids, groups, permissions):
        """
        Parameters:
         - session
         - dashboard_ids
         - groups
         - permissions

        """
        self.send_unshare_dashboards(session, dashboard_ids, groups, permissions)
        self.recv_unshare_dashboards()

    def send_unshare_dashboards(self, session, dashboard_ids, groups, permissions):
        self._oprot.writeMessageBegin('unshare_dashboards', TMessageType.CALL, self._seqid)
        args = unshare_dashboards_args()
        args.session = session
        args.dashboard_ids = dashboard_ids
        args.groups = groups
        args.permissions = permissions
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_unshare_dashboards(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = unshare_dashboards_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def get_dashboard_grantees(self, session, dashboard_id):
        """
        Parameters:
         - session
         - dashboard_id

        """
        self.send_get_dashboard_grantees(session, dashboard_id)
        return self.recv_get_dashboard_grantees()

    def send_get_dashboard_grantees(self, session, dashboard_id):
        self._oprot.writeMessageBegin('get_dashboard_grantees', TMessageType.CALL, self._seqid)
        args = get_dashboard_grantees_args()
        args.session = session
        args.dashboard_id = dashboard_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_dashboard_grantees(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_dashboard_grantees_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_dashboard_grantees failed: unknown result")

    def get_link_view(self, session, link):
        """
        Parameters:
         - session
         - link

        """
        self.send_get_link_view(session, link)
        return self.recv_get_link_view()

    def send_get_link_view(self, session, link):
        self._oprot.writeMessageBegin('get_link_view', TMessageType.CALL, self._seqid)
        args = get_link_view_args()
        args.session = session
        args.link = link
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_link_view(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_link_view_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_link_view failed: unknown result")

    def create_link(self, session, view_state, view_metadata):
        """
        Parameters:
         - session
         - view_state
         - view_metadata

        """
        self.send_create_link(session, view_state, view_metadata)
        return self.recv_create_link()

    def send_create_link(self, session, view_state, view_metadata):
        self._oprot.writeMessageBegin('create_link', TMessageType.CALL, self._seqid)
        args = create_link_args()
        args.session = session
        args.view_state = view_state
        args.view_metadata = view_metadata
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_create_link(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = create_link_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "create_link failed: unknown result")

    def load_table_binary(self, session, table_name, rows):
        """
        Parameters:
         - session
         - table_name
         - rows

        """
        self.send_load_table_binary(session, table_name, rows)
        self.recv_load_table_binary()

    def send_load_table_binary(self, session, table_name, rows):
        self._oprot.writeMessageBegin('load_table_binary', TMessageType.CALL, self._seqid)
        args = load_table_binary_args()
        args.session = session
        args.table_name = table_name
        args.rows = rows
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_load_table_binary(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = load_table_binary_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def load_table_binary_columnar(self, session, table_name, cols):
        """
        Parameters:
         - session
         - table_name
         - cols

        """
        self.send_load_table_binary_columnar(session, table_name, cols)
        self.recv_load_table_binary_columnar()

    def send_load_table_binary_columnar(self, session, table_name, cols):
        self._oprot.writeMessageBegin('load_table_binary_columnar', TMessageType.CALL, self._seqid)
        args = load_table_binary_columnar_args()
        args.session = session
        args.table_name = table_name
        args.cols = cols
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_load_table_binary_columnar(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = load_table_binary_columnar_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def load_table_binary_arrow(self, session, table_name, arrow_stream):
        """
        Parameters:
         - session
         - table_name
         - arrow_stream

        """
        self.send_load_table_binary_arrow(session, table_name, arrow_stream)
        self.recv_load_table_binary_arrow()

    def send_load_table_binary_arrow(self, session, table_name, arrow_stream):
        self._oprot.writeMessageBegin('load_table_binary_arrow', TMessageType.CALL, self._seqid)
        args = load_table_binary_arrow_args()
        args.session = session
        args.table_name = table_name
        args.arrow_stream = arrow_stream
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_load_table_binary_arrow(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = load_table_binary_arrow_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def load_table(self, session, table_name, rows):
        """
        Parameters:
         - session
         - table_name
         - rows

        """
        self.send_load_table(session, table_name, rows)
        self.recv_load_table()

    def send_load_table(self, session, table_name, rows):
        self._oprot.writeMessageBegin('load_table', TMessageType.CALL, self._seqid)
        args = load_table_args()
        args.session = session
        args.table_name = table_name
        args.rows = rows
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_load_table(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = load_table_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def detect_column_types(self, session, file_name, copy_params):
        """
        Parameters:
         - session
         - file_name
         - copy_params

        """
        self.send_detect_column_types(session, file_name, copy_params)
        return self.recv_detect_column_types()

    def send_detect_column_types(self, session, file_name, copy_params):
        self._oprot.writeMessageBegin('detect_column_types', TMessageType.CALL, self._seqid)
        args = detect_column_types_args()
        args.session = session
        args.file_name = file_name
        args.copy_params = copy_params
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_detect_column_types(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = detect_column_types_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "detect_column_types failed: unknown result")

    def create_table(self, session, table_name, row_desc, file_type, create_params):
        """
        Parameters:
         - session
         - table_name
         - row_desc
         - file_type
         - create_params

        """
        self.send_create_table(session, table_name, row_desc, file_type, create_params)
        self.recv_create_table()

    def send_create_table(self, session, table_name, row_desc, file_type, create_params):
        self._oprot.writeMessageBegin('create_table', TMessageType.CALL, self._seqid)
        args = create_table_args()
        args.session = session
        args.table_name = table_name
        args.row_desc = row_desc
        args.file_type = file_type
        args.create_params = create_params
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_create_table(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = create_table_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def import_table(self, session, table_name, file_name, copy_params):
        """
        Parameters:
         - session
         - table_name
         - file_name
         - copy_params

        """
        self.send_import_table(session, table_name, file_name, copy_params)
        self.recv_import_table()

    def send_import_table(self, session, table_name, file_name, copy_params):
        self._oprot.writeMessageBegin('import_table', TMessageType.CALL, self._seqid)
        args = import_table_args()
        args.session = session
        args.table_name = table_name
        args.file_name = file_name
        args.copy_params = copy_params
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_import_table(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = import_table_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def import_geo_table(self, session, table_name, file_name, copy_params, row_desc, create_params):
        """
        Parameters:
         - session
         - table_name
         - file_name
         - copy_params
         - row_desc
         - create_params

        """
        self.send_import_geo_table(session, table_name, file_name, copy_params, row_desc, create_params)
        self.recv_import_geo_table()

    def send_import_geo_table(self, session, table_name, file_name, copy_params, row_desc, create_params):
        self._oprot.writeMessageBegin('import_geo_table', TMessageType.CALL, self._seqid)
        args = import_geo_table_args()
        args.session = session
        args.table_name = table_name
        args.file_name = file_name
        args.copy_params = copy_params
        args.row_desc = row_desc
        args.create_params = create_params
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_import_geo_table(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = import_geo_table_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def import_table_status(self, session, import_id):
        """
        Parameters:
         - session
         - import_id

        """
        self.send_import_table_status(session, import_id)
        return self.recv_import_table_status()

    def send_import_table_status(self, session, import_id):
        self._oprot.writeMessageBegin('import_table_status', TMessageType.CALL, self._seqid)
        args = import_table_status_args()
        args.session = session
        args.import_id = import_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_import_table_status(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = import_table_status_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "import_table_status failed: unknown result")

    def get_first_geo_file_in_archive(self, session, archive_path, copy_params):
        """
        Parameters:
         - session
         - archive_path
         - copy_params

        """
        self.send_get_first_geo_file_in_archive(session, archive_path, copy_params)
        return self.recv_get_first_geo_file_in_archive()

    def send_get_first_geo_file_in_archive(self, session, archive_path, copy_params):
        self._oprot.writeMessageBegin('get_first_geo_file_in_archive', TMessageType.CALL, self._seqid)
        args = get_first_geo_file_in_archive_args()
        args.session = session
        args.archive_path = archive_path
        args.copy_params = copy_params
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_first_geo_file_in_archive(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_first_geo_file_in_archive_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_first_geo_file_in_archive failed: unknown result")

    def get_all_files_in_archive(self, session, archive_path, copy_params):
        """
        Parameters:
         - session
         - archive_path
         - copy_params

        """
        self.send_get_all_files_in_archive(session, archive_path, copy_params)
        return self.recv_get_all_files_in_archive()

    def send_get_all_files_in_archive(self, session, archive_path, copy_params):
        self._oprot.writeMessageBegin('get_all_files_in_archive', TMessageType.CALL, self._seqid)
        args = get_all_files_in_archive_args()
        args.session = session
        args.archive_path = archive_path
        args.copy_params = copy_params
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_all_files_in_archive(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_all_files_in_archive_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_all_files_in_archive failed: unknown result")

    def get_layers_in_geo_file(self, session, file_name, copy_params):
        """
        Parameters:
         - session
         - file_name
         - copy_params

        """
        self.send_get_layers_in_geo_file(session, file_name, copy_params)
        return self.recv_get_layers_in_geo_file()

    def send_get_layers_in_geo_file(self, session, file_name, copy_params):
        self._oprot.writeMessageBegin('get_layers_in_geo_file', TMessageType.CALL, self._seqid)
        args = get_layers_in_geo_file_args()
        args.session = session
        args.file_name = file_name
        args.copy_params = copy_params
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_layers_in_geo_file(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_layers_in_geo_file_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_layers_in_geo_file failed: unknown result")

    def query_get_outer_fragment_count(self, session, query):
        """
        Parameters:
         - session
         - query

        """
        self.send_query_get_outer_fragment_count(session, query)
        return self.recv_query_get_outer_fragment_count()

    def send_query_get_outer_fragment_count(self, session, query):
        self._oprot.writeMessageBegin('query_get_outer_fragment_count', TMessageType.CALL, self._seqid)
        args = query_get_outer_fragment_count_args()
        args.session = session
        args.query = query
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_query_get_outer_fragment_count(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = query_get_outer_fragment_count_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "query_get_outer_fragment_count failed: unknown result")

    def check_table_consistency(self, session, table_id):
        """
        Parameters:
         - session
         - table_id

        """
        self.send_check_table_consistency(session, table_id)
        return self.recv_check_table_consistency()

    def send_check_table_consistency(self, session, table_id):
        self._oprot.writeMessageBegin('check_table_consistency', TMessageType.CALL, self._seqid)
        args = check_table_consistency_args()
        args.session = session
        args.table_id = table_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_check_table_consistency(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = check_table_consistency_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "check_table_consistency failed: unknown result")

    def start_query(self, leaf_session, parent_session, query_ra, just_explain, outer_fragment_indices):
        """
        Parameters:
         - leaf_session
         - parent_session
         - query_ra
         - just_explain
         - outer_fragment_indices

        """
        self.send_start_query(leaf_session, parent_session, query_ra, just_explain, outer_fragment_indices)
        return self.recv_start_query()

    def send_start_query(self, leaf_session, parent_session, query_ra, just_explain, outer_fragment_indices):
        self._oprot.writeMessageBegin('start_query', TMessageType.CALL, self._seqid)
        args = start_query_args()
        args.leaf_session = leaf_session
        args.parent_session = parent_session
        args.query_ra = query_ra
        args.just_explain = just_explain
        args.outer_fragment_indices = outer_fragment_indices
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_start_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = start_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "start_query failed: unknown result")

    def execute_query_step(self, pending_query):
        """
        Parameters:
         - pending_query

        """
        self.send_execute_query_step(pending_query)
        return self.recv_execute_query_step()

    def send_execute_query_step(self, pending_query):
        self._oprot.writeMessageBegin('execute_query_step', TMessageType.CALL, self._seqid)
        args = execute_query_step_args()
        args.pending_query = pending_query
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_execute_query_step(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = execute_query_step_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "execute_query_step failed: unknown result")

    def broadcast_serialized_rows(self, serialized_rows, row_desc, query_id):
        """
        Parameters:
         - serialized_rows
         - row_desc
         - query_id

        """
        self.send_broadcast_serialized_rows(serialized_rows, row_desc, query_id)
        self.recv_broadcast_serialized_rows()

    def send_broadcast_serialized_rows(self, serialized_rows, row_desc, query_id):
        self._oprot.writeMessageBegin('broadcast_serialized_rows', TMessageType.CALL, self._seqid)
        args = broadcast_serialized_rows_args()
        args.serialized_rows = serialized_rows
        args.row_desc = row_desc
        args.query_id = query_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_broadcast_serialized_rows(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = broadcast_serialized_rows_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def start_render_query(self, session, widget_id, node_idx, vega_json):
        """
        Parameters:
         - session
         - widget_id
         - node_idx
         - vega_json

        """
        self.send_start_render_query(session, widget_id, node_idx, vega_json)
        return self.recv_start_render_query()

    def send_start_render_query(self, session, widget_id, node_idx, vega_json):
        self._oprot.writeMessageBegin('start_render_query', TMessageType.CALL, self._seqid)
        args = start_render_query_args()
        args.session = session
        args.widget_id = widget_id
        args.node_idx = node_idx
        args.vega_json = vega_json
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_start_render_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = start_render_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "start_render_query failed: unknown result")

    def execute_next_render_step(self, pending_render, merged_data):
        """
        Parameters:
         - pending_render
         - merged_data

        """
        self.send_execute_next_render_step(pending_render, merged_data)
        return self.recv_execute_next_render_step()

    def send_execute_next_render_step(self, pending_render, merged_data):
        self._oprot.writeMessageBegin('execute_next_render_step', TMessageType.CALL, self._seqid)
        args = execute_next_render_step_args()
        args.pending_render = pending_render
        args.merged_data = merged_data
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_execute_next_render_step(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = execute_next_render_step_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "execute_next_render_step failed: unknown result")

    def insert_data(self, session, insert_data):
        """
        Parameters:
         - session
         - insert_data

        """
        self.send_insert_data(session, insert_data)
        self.recv_insert_data()

    def send_insert_data(self, session, insert_data):
        self._oprot.writeMessageBegin('insert_data', TMessageType.CALL, self._seqid)
        args = insert_data_args()
        args.session = session
        args.insert_data = insert_data
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_insert_data(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = insert_data_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def checkpoint(self, session, db_id, table_id):
        """
        Parameters:
         - session
         - db_id
         - table_id

        """
        self.send_checkpoint(session, db_id, table_id)
        self.recv_checkpoint()

    def send_checkpoint(self, session, db_id, table_id):
        self._oprot.writeMessageBegin('checkpoint', TMessageType.CALL, self._seqid)
        args = checkpoint_args()
        args.session = session
        args.db_id = db_id
        args.table_id = table_id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_checkpoint(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = checkpoint_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return

    def get_roles(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_roles(session)
        return self.recv_get_roles()

    def send_get_roles(self, session):
        self._oprot.writeMessageBegin('get_roles', TMessageType.CALL, self._seqid)
        args = get_roles_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_roles(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_roles_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_roles failed: unknown result")

    def get_db_objects_for_grantee(self, session, roleName):
        """
        Parameters:
         - session
         - roleName

        """
        self.send_get_db_objects_for_grantee(session, roleName)
        return self.recv_get_db_objects_for_grantee()

    def send_get_db_objects_for_grantee(self, session, roleName):
        self._oprot.writeMessageBegin('get_db_objects_for_grantee', TMessageType.CALL, self._seqid)
        args = get_db_objects_for_grantee_args()
        args.session = session
        args.roleName = roleName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_db_objects_for_grantee(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_db_objects_for_grantee_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_db_objects_for_grantee failed: unknown result")

    def get_db_object_privs(self, session, objectName, type):
        """
        Parameters:
         - session
         - objectName
         - type

        """
        self.send_get_db_object_privs(session, objectName, type)
        return self.recv_get_db_object_privs()

    def send_get_db_object_privs(self, session, objectName, type):
        self._oprot.writeMessageBegin('get_db_object_privs', TMessageType.CALL, self._seqid)
        args = get_db_object_privs_args()
        args.session = session
        args.objectName = objectName
        args.type = type
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_db_object_privs(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_db_object_privs_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_db_object_privs failed: unknown result")

    def get_all_roles_for_user(self, session, userName):
        """
        Parameters:
         - session
         - userName

        """
        self.send_get_all_roles_for_user(session, userName)
        return self.recv_get_all_roles_for_user()

    def send_get_all_roles_for_user(self, session, userName):
        self._oprot.writeMessageBegin('get_all_roles_for_user', TMessageType.CALL, self._seqid)
        args = get_all_roles_for_user_args()
        args.session = session
        args.userName = userName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_all_roles_for_user(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_all_roles_for_user_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_all_roles_for_user failed: unknown result")

    def has_role(self, session, granteeName, roleName):
        """
        Parameters:
         - session
         - granteeName
         - roleName

        """
        self.send_has_role(session, granteeName, roleName)
        return self.recv_has_role()

    def send_has_role(self, session, granteeName, roleName):
        self._oprot.writeMessageBegin('has_role', TMessageType.CALL, self._seqid)
        args = has_role_args()
        args.session = session
        args.granteeName = granteeName
        args.roleName = roleName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_has_role(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = has_role_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "has_role failed: unknown result")

    def has_object_privilege(self, session, granteeName, ObjectName, objectType, permissions):
        """
        Parameters:
         - session
         - granteeName
         - ObjectName
         - objectType
         - permissions

        """
        self.send_has_object_privilege(session, granteeName, ObjectName, objectType, permissions)
        return self.recv_has_object_privilege()

    def send_has_object_privilege(self, session, granteeName, ObjectName, objectType, permissions):
        self._oprot.writeMessageBegin('has_object_privilege', TMessageType.CALL, self._seqid)
        args = has_object_privilege_args()
        args.session = session
        args.granteeName = granteeName
        args.ObjectName = ObjectName
        args.objectType = objectType
        args.permissions = permissions
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_has_object_privilege(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = has_object_privilege_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "has_object_privilege failed: unknown result")

    def set_license_key(self, session, key, nonce):
        """
        Parameters:
         - session
         - key
         - nonce

        """
        self.send_set_license_key(session, key, nonce)
        return self.recv_set_license_key()

    def send_set_license_key(self, session, key, nonce):
        self._oprot.writeMessageBegin('set_license_key', TMessageType.CALL, self._seqid)
        args = set_license_key_args()
        args.session = session
        args.key = key
        args.nonce = nonce
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_set_license_key(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = set_license_key_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "set_license_key failed: unknown result")

    def get_license_claims(self, session, nonce):
        """
        Parameters:
         - session
         - nonce

        """
        self.send_get_license_claims(session, nonce)
        return self.recv_get_license_claims()

    def send_get_license_claims(self, session, nonce):
        self._oprot.writeMessageBegin('get_license_claims', TMessageType.CALL, self._seqid)
        args = get_license_claims_args()
        args.session = session
        args.nonce = nonce
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_license_claims(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_license_claims_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_license_claims failed: unknown result")

    def get_device_parameters(self, session):
        """
        Parameters:
         - session

        """
        self.send_get_device_parameters(session)
        return self.recv_get_device_parameters()

    def send_get_device_parameters(self, session):
        self._oprot.writeMessageBegin('get_device_parameters', TMessageType.CALL, self._seqid)
        args = get_device_parameters_args()
        args.session = session
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_device_parameters(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_device_parameters_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.e is not None:
            raise result.e
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_device_parameters failed: unknown result")

    def register_runtime_extension_functions(self, session, udfs, udtfs, device_ir_map):
        """
        Parameters:
         - session
         - udfs
         - udtfs
         - device_ir_map

        """
        self.send_register_runtime_extension_functions(session, udfs, udtfs, device_ir_map)
        self.recv_register_runtime_extension_functions()

    def send_register_runtime_extension_functions(self, session, udfs, udtfs, device_ir_map):
        self._oprot.writeMessageBegin('register_runtime_extension_functions', TMessageType.CALL, self._seqid)
        args = register_runtime_extension_functions_args()
        args.session = session
        args.udfs = udfs
        args.udtfs = udtfs
        args.device_ir_map = device_ir_map
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_register_runtime_extension_functions(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = register_runtime_extension_functions_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.e is not None:
            raise result.e
        return


class Processor(Iface, TProcessor):
    def __init__(self, handler):
        self._handler = handler
        self._processMap = {}
        self._processMap["connect"] = Processor.process_connect
        self._processMap["krb5_connect"] = Processor.process_krb5_connect
        self._processMap["disconnect"] = Processor.process_disconnect
        self._processMap["switch_database"] = Processor.process_switch_database
        self._processMap["clone_session"] = Processor.process_clone_session
        self._processMap["get_server_status"] = Processor.process_get_server_status
        self._processMap["get_status"] = Processor.process_get_status
        self._processMap["get_hardware_info"] = Processor.process_get_hardware_info
        self._processMap["get_tables"] = Processor.process_get_tables
        self._processMap["get_physical_tables"] = Processor.process_get_physical_tables
        self._processMap["get_views"] = Processor.process_get_views
        self._processMap["get_tables_meta"] = Processor.process_get_tables_meta
        self._processMap["get_table_details"] = Processor.process_get_table_details
        self._processMap["get_internal_table_details"] = Processor.process_get_internal_table_details
        self._processMap["get_users"] = Processor.process_get_users
        self._processMap["get_databases"] = Processor.process_get_databases
        self._processMap["get_version"] = Processor.process_get_version
        self._processMap["start_heap_profile"] = Processor.process_start_heap_profile
        self._processMap["stop_heap_profile"] = Processor.process_stop_heap_profile
        self._processMap["get_heap_profile"] = Processor.process_get_heap_profile
        self._processMap["get_memory"] = Processor.process_get_memory
        self._processMap["clear_cpu_memory"] = Processor.process_clear_cpu_memory
        self._processMap["clear_gpu_memory"] = Processor.process_clear_gpu_memory
        self._processMap["set_table_epoch"] = Processor.process_set_table_epoch
        self._processMap["set_table_epoch_by_name"] = Processor.process_set_table_epoch_by_name
        self._processMap["get_table_epoch"] = Processor.process_get_table_epoch
        self._processMap["get_table_epoch_by_name"] = Processor.process_get_table_epoch_by_name
        self._processMap["get_session_info"] = Processor.process_get_session_info
        self._processMap["sql_execute"] = Processor.process_sql_execute
        self._processMap["sql_execute_df"] = Processor.process_sql_execute_df
        self._processMap["sql_execute_gdf"] = Processor.process_sql_execute_gdf
        self._processMap["deallocate_df"] = Processor.process_deallocate_df
        self._processMap["interrupt"] = Processor.process_interrupt
        self._processMap["sql_validate"] = Processor.process_sql_validate
        self._processMap["get_completion_hints"] = Processor.process_get_completion_hints
        self._processMap["set_execution_mode"] = Processor.process_set_execution_mode
        self._processMap["render_vega"] = Processor.process_render_vega
        self._processMap["get_result_row_for_pixel"] = Processor.process_get_result_row_for_pixel
        self._processMap["get_dashboard"] = Processor.process_get_dashboard
        self._processMap["get_dashboards"] = Processor.process_get_dashboards
        self._processMap["create_dashboard"] = Processor.process_create_dashboard
        self._processMap["replace_dashboard"] = Processor.process_replace_dashboard
        self._processMap["delete_dashboard"] = Processor.process_delete_dashboard
        self._processMap["share_dashboards"] = Processor.process_share_dashboards
        self._processMap["delete_dashboards"] = Processor.process_delete_dashboards
        self._processMap["share_dashboard"] = Processor.process_share_dashboard
        self._processMap["unshare_dashboard"] = Processor.process_unshare_dashboard
        self._processMap["unshare_dashboards"] = Processor.process_unshare_dashboards
        self._processMap["get_dashboard_grantees"] = Processor.process_get_dashboard_grantees
        self._processMap["get_link_view"] = Processor.process_get_link_view
        self._processMap["create_link"] = Processor.process_create_link
        self._processMap["load_table_binary"] = Processor.process_load_table_binary
        self._processMap["load_table_binary_columnar"] = Processor.process_load_table_binary_columnar
        self._processMap["load_table_binary_arrow"] = Processor.process_load_table_binary_arrow
        self._processMap["load_table"] = Processor.process_load_table
        self._processMap["detect_column_types"] = Processor.process_detect_column_types
        self._processMap["create_table"] = Processor.process_create_table
        self._processMap["import_table"] = Processor.process_import_table
        self._processMap["import_geo_table"] = Processor.process_import_geo_table
        self._processMap["import_table_status"] = Processor.process_import_table_status
        self._processMap["get_first_geo_file_in_archive"] = Processor.process_get_first_geo_file_in_archive
        self._processMap["get_all_files_in_archive"] = Processor.process_get_all_files_in_archive
        self._processMap["get_layers_in_geo_file"] = Processor.process_get_layers_in_geo_file
        self._processMap["query_get_outer_fragment_count"] = Processor.process_query_get_outer_fragment_count
        self._processMap["check_table_consistency"] = Processor.process_check_table_consistency
        self._processMap["start_query"] = Processor.process_start_query
        self._processMap["execute_query_step"] = Processor.process_execute_query_step
        self._processMap["broadcast_serialized_rows"] = Processor.process_broadcast_serialized_rows
        self._processMap["start_render_query"] = Processor.process_start_render_query
        self._processMap["execute_next_render_step"] = Processor.process_execute_next_render_step
        self._processMap["insert_data"] = Processor.process_insert_data
        self._processMap["checkpoint"] = Processor.process_checkpoint
        self._processMap["get_roles"] = Processor.process_get_roles
        self._processMap["get_db_objects_for_grantee"] = Processor.process_get_db_objects_for_grantee
        self._processMap["get_db_object_privs"] = Processor.process_get_db_object_privs
        self._processMap["get_all_roles_for_user"] = Processor.process_get_all_roles_for_user
        self._processMap["has_role"] = Processor.process_has_role
        self._processMap["has_object_privilege"] = Processor.process_has_object_privilege
        self._processMap["set_license_key"] = Processor.process_set_license_key
        self._processMap["get_license_claims"] = Processor.process_get_license_claims
        self._processMap["get_device_parameters"] = Processor.process_get_device_parameters
        self._processMap["register_runtime_extension_functions"] = Processor.process_register_runtime_extension_functions
        self._on_message_begin = None

    def on_message_begin(self, func):
        self._on_message_begin = func

    def process(self, iprot, oprot):
        (name, type, seqid) = iprot.readMessageBegin()
        if self._on_message_begin:
            self._on_message_begin(name, type, seqid)
        if name not in self._processMap:
            iprot.skip(TType.STRUCT)
            iprot.readMessageEnd()
            x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
            oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
            x.write(oprot)
            oprot.writeMessageEnd()
            oprot.trans.flush()
            return
        else:
            self._processMap[name](self, seqid, iprot, oprot)
        return True

    def process_connect(self, seqid, iprot, oprot):
        args = connect_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = connect_result()
        try:
            result.success = self._handler.connect(args.user, args.passwd, args.dbname)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("connect", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_krb5_connect(self, seqid, iprot, oprot):
        args = krb5_connect_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = krb5_connect_result()
        try:
            result.success = self._handler.krb5_connect(args.inputToken, args.dbname)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("krb5_connect", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_disconnect(self, seqid, iprot, oprot):
        args = disconnect_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = disconnect_result()
        try:
            self._handler.disconnect(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("disconnect", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_switch_database(self, seqid, iprot, oprot):
        args = switch_database_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = switch_database_result()
        try:
            self._handler.switch_database(args.session, args.dbname)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("switch_database", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_clone_session(self, seqid, iprot, oprot):
        args = clone_session_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = clone_session_result()
        try:
            result.success = self._handler.clone_session(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("clone_session", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_server_status(self, seqid, iprot, oprot):
        args = get_server_status_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_server_status_result()
        try:
            result.success = self._handler.get_server_status(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_server_status", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_status(self, seqid, iprot, oprot):
        args = get_status_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_status_result()
        try:
            result.success = self._handler.get_status(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_status", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_hardware_info(self, seqid, iprot, oprot):
        args = get_hardware_info_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_hardware_info_result()
        try:
            result.success = self._handler.get_hardware_info(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_hardware_info", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_tables(self, seqid, iprot, oprot):
        args = get_tables_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_tables_result()
        try:
            result.success = self._handler.get_tables(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_tables", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_physical_tables(self, seqid, iprot, oprot):
        args = get_physical_tables_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_physical_tables_result()
        try:
            result.success = self._handler.get_physical_tables(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_physical_tables", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_views(self, seqid, iprot, oprot):
        args = get_views_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_views_result()
        try:
            result.success = self._handler.get_views(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_views", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_tables_meta(self, seqid, iprot, oprot):
        args = get_tables_meta_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_tables_meta_result()
        try:
            result.success = self._handler.get_tables_meta(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_tables_meta", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_table_details(self, seqid, iprot, oprot):
        args = get_table_details_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_table_details_result()
        try:
            result.success = self._handler.get_table_details(args.session, args.table_name)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_table_details", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_internal_table_details(self, seqid, iprot, oprot):
        args = get_internal_table_details_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_internal_table_details_result()
        try:
            result.success = self._handler.get_internal_table_details(args.session, args.table_name)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_internal_table_details", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_users(self, seqid, iprot, oprot):
        args = get_users_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_users_result()
        try:
            result.success = self._handler.get_users(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_users", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_databases(self, seqid, iprot, oprot):
        args = get_databases_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_databases_result()
        try:
            result.success = self._handler.get_databases(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_databases", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_version(self, seqid, iprot, oprot):
        args = get_version_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_version_result()
        try:
            result.success = self._handler.get_version()
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_version", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_start_heap_profile(self, seqid, iprot, oprot):
        args = start_heap_profile_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = start_heap_profile_result()
        try:
            self._handler.start_heap_profile(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("start_heap_profile", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_stop_heap_profile(self, seqid, iprot, oprot):
        args = stop_heap_profile_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = stop_heap_profile_result()
        try:
            self._handler.stop_heap_profile(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("stop_heap_profile", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_heap_profile(self, seqid, iprot, oprot):
        args = get_heap_profile_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_heap_profile_result()
        try:
            result.success = self._handler.get_heap_profile(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_heap_profile", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_memory(self, seqid, iprot, oprot):
        args = get_memory_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_memory_result()
        try:
            result.success = self._handler.get_memory(args.session, args.memory_level)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_memory", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_clear_cpu_memory(self, seqid, iprot, oprot):
        args = clear_cpu_memory_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = clear_cpu_memory_result()
        try:
            self._handler.clear_cpu_memory(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("clear_cpu_memory", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_clear_gpu_memory(self, seqid, iprot, oprot):
        args = clear_gpu_memory_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = clear_gpu_memory_result()
        try:
            self._handler.clear_gpu_memory(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("clear_gpu_memory", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_set_table_epoch(self, seqid, iprot, oprot):
        args = set_table_epoch_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = set_table_epoch_result()
        try:
            self._handler.set_table_epoch(args.session, args.db_id, args.table_id, args.new_epoch)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("set_table_epoch", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_set_table_epoch_by_name(self, seqid, iprot, oprot):
        args = set_table_epoch_by_name_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = set_table_epoch_by_name_result()
        try:
            self._handler.set_table_epoch_by_name(args.session, args.table_name, args.new_epoch)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("set_table_epoch_by_name", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_table_epoch(self, seqid, iprot, oprot):
        args = get_table_epoch_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_table_epoch_result()
        try:
            result.success = self._handler.get_table_epoch(args.session, args.db_id, args.table_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_table_epoch", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_table_epoch_by_name(self, seqid, iprot, oprot):
        args = get_table_epoch_by_name_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_table_epoch_by_name_result()
        try:
            result.success = self._handler.get_table_epoch_by_name(args.session, args.table_name)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_table_epoch_by_name", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_session_info(self, seqid, iprot, oprot):
        args = get_session_info_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_session_info_result()
        try:
            result.success = self._handler.get_session_info(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_session_info", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_sql_execute(self, seqid, iprot, oprot):
        args = sql_execute_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = sql_execute_result()
        try:
            result.success = self._handler.sql_execute(args.session, args.query, args.column_format, args.nonce, args.first_n, args.at_most_n)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("sql_execute", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_sql_execute_df(self, seqid, iprot, oprot):
        args = sql_execute_df_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = sql_execute_df_result()
        try:
            result.success = self._handler.sql_execute_df(args.session, args.query, args.device_type, args.device_id, args.first_n, args.transport_method)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("sql_execute_df", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_sql_execute_gdf(self, seqid, iprot, oprot):
        args = sql_execute_gdf_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = sql_execute_gdf_result()
        try:
            result.success = self._handler.sql_execute_gdf(args.session, args.query, args.device_id, args.first_n)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("sql_execute_gdf", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_deallocate_df(self, seqid, iprot, oprot):
        args = deallocate_df_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = deallocate_df_result()
        try:
            self._handler.deallocate_df(args.session, args.df, args.device_type, args.device_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("deallocate_df", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_interrupt(self, seqid, iprot, oprot):
        args = interrupt_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = interrupt_result()
        try:
            self._handler.interrupt(args.query_session, args.interrupt_session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("interrupt", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_sql_validate(self, seqid, iprot, oprot):
        args = sql_validate_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = sql_validate_result()
        try:
            result.success = self._handler.sql_validate(args.session, args.query)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("sql_validate", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_completion_hints(self, seqid, iprot, oprot):
        args = get_completion_hints_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_completion_hints_result()
        try:
            result.success = self._handler.get_completion_hints(args.session, args.sql, args.cursor)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_completion_hints", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_set_execution_mode(self, seqid, iprot, oprot):
        args = set_execution_mode_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = set_execution_mode_result()
        try:
            self._handler.set_execution_mode(args.session, args.mode)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("set_execution_mode", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_render_vega(self, seqid, iprot, oprot):
        args = render_vega_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = render_vega_result()
        try:
            result.success = self._handler.render_vega(args.session, args.widget_id, args.vega_json, args.compression_level, args.nonce)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("render_vega", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_result_row_for_pixel(self, seqid, iprot, oprot):
        args = get_result_row_for_pixel_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_result_row_for_pixel_result()
        try:
            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)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_result_row_for_pixel", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_dashboard(self, seqid, iprot, oprot):
        args = get_dashboard_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_dashboard_result()
        try:
            result.success = self._handler.get_dashboard(args.session, args.dashboard_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_dashboard", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_dashboards(self, seqid, iprot, oprot):
        args = get_dashboards_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_dashboards_result()
        try:
            result.success = self._handler.get_dashboards(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_dashboards", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_create_dashboard(self, seqid, iprot, oprot):
        args = create_dashboard_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = create_dashboard_result()
        try:
            result.success = self._handler.create_dashboard(args.session, args.dashboard_name, args.dashboard_state, args.image_hash, args.dashboard_metadata)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("create_dashboard", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_replace_dashboard(self, seqid, iprot, oprot):
        args = replace_dashboard_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = replace_dashboard_result()
        try:
            self._handler.replace_dashboard(args.session, args.dashboard_id, args.dashboard_name, args.dashboard_owner, args.dashboard_state, args.image_hash, args.dashboard_metadata)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("replace_dashboard", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_delete_dashboard(self, seqid, iprot, oprot):
        args = delete_dashboard_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = delete_dashboard_result()
        try:
            self._handler.delete_dashboard(args.session, args.dashboard_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("delete_dashboard", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_share_dashboards(self, seqid, iprot, oprot):
        args = share_dashboards_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = share_dashboards_result()
        try:
            self._handler.share_dashboards(args.session, args.dashboard_ids, args.groups, args.permissions)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("share_dashboards", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_delete_dashboards(self, seqid, iprot, oprot):
        args = delete_dashboards_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = delete_dashboards_result()
        try:
            self._handler.delete_dashboards(args.session, args.dashboard_ids)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("delete_dashboards", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_share_dashboard(self, seqid, iprot, oprot):
        args = share_dashboard_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = share_dashboard_result()
        try:
            self._handler.share_dashboard(args.session, args.dashboard_id, args.groups, args.objects, args.permissions, args.grant_role)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("share_dashboard", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_unshare_dashboard(self, seqid, iprot, oprot):
        args = unshare_dashboard_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = unshare_dashboard_result()
        try:
            self._handler.unshare_dashboard(args.session, args.dashboard_id, args.groups, args.objects, args.permissions)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("unshare_dashboard", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_unshare_dashboards(self, seqid, iprot, oprot):
        args = unshare_dashboards_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = unshare_dashboards_result()
        try:
            self._handler.unshare_dashboards(args.session, args.dashboard_ids, args.groups, args.permissions)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("unshare_dashboards", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_dashboard_grantees(self, seqid, iprot, oprot):
        args = get_dashboard_grantees_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_dashboard_grantees_result()
        try:
            result.success = self._handler.get_dashboard_grantees(args.session, args.dashboard_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_dashboard_grantees", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_link_view(self, seqid, iprot, oprot):
        args = get_link_view_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_link_view_result()
        try:
            result.success = self._handler.get_link_view(args.session, args.link)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_link_view", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_create_link(self, seqid, iprot, oprot):
        args = create_link_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = create_link_result()
        try:
            result.success = self._handler.create_link(args.session, args.view_state, args.view_metadata)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("create_link", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_load_table_binary(self, seqid, iprot, oprot):
        args = load_table_binary_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = load_table_binary_result()
        try:
            self._handler.load_table_binary(args.session, args.table_name, args.rows)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("load_table_binary", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_load_table_binary_columnar(self, seqid, iprot, oprot):
        args = load_table_binary_columnar_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = load_table_binary_columnar_result()
        try:
            self._handler.load_table_binary_columnar(args.session, args.table_name, args.cols)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("load_table_binary_columnar", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_load_table_binary_arrow(self, seqid, iprot, oprot):
        args = load_table_binary_arrow_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = load_table_binary_arrow_result()
        try:
            self._handler.load_table_binary_arrow(args.session, args.table_name, args.arrow_stream)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("load_table_binary_arrow", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_load_table(self, seqid, iprot, oprot):
        args = load_table_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = load_table_result()
        try:
            self._handler.load_table(args.session, args.table_name, args.rows)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("load_table", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_detect_column_types(self, seqid, iprot, oprot):
        args = detect_column_types_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = detect_column_types_result()
        try:
            result.success = self._handler.detect_column_types(args.session, args.file_name, args.copy_params)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("detect_column_types", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_create_table(self, seqid, iprot, oprot):
        args = create_table_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = create_table_result()
        try:
            self._handler.create_table(args.session, args.table_name, args.row_desc, args.file_type, args.create_params)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("create_table", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_import_table(self, seqid, iprot, oprot):
        args = import_table_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = import_table_result()
        try:
            self._handler.import_table(args.session, args.table_name, args.file_name, args.copy_params)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("import_table", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_import_geo_table(self, seqid, iprot, oprot):
        args = import_geo_table_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = import_geo_table_result()
        try:
            self._handler.import_geo_table(args.session, args.table_name, args.file_name, args.copy_params, args.row_desc, args.create_params)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("import_geo_table", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_import_table_status(self, seqid, iprot, oprot):
        args = import_table_status_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = import_table_status_result()
        try:
            result.success = self._handler.import_table_status(args.session, args.import_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("import_table_status", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_first_geo_file_in_archive(self, seqid, iprot, oprot):
        args = get_first_geo_file_in_archive_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_first_geo_file_in_archive_result()
        try:
            result.success = self._handler.get_first_geo_file_in_archive(args.session, args.archive_path, args.copy_params)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_first_geo_file_in_archive", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_all_files_in_archive(self, seqid, iprot, oprot):
        args = get_all_files_in_archive_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_all_files_in_archive_result()
        try:
            result.success = self._handler.get_all_files_in_archive(args.session, args.archive_path, args.copy_params)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_all_files_in_archive", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_layers_in_geo_file(self, seqid, iprot, oprot):
        args = get_layers_in_geo_file_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_layers_in_geo_file_result()
        try:
            result.success = self._handler.get_layers_in_geo_file(args.session, args.file_name, args.copy_params)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_layers_in_geo_file", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_query_get_outer_fragment_count(self, seqid, iprot, oprot):
        args = query_get_outer_fragment_count_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = query_get_outer_fragment_count_result()
        try:
            result.success = self._handler.query_get_outer_fragment_count(args.session, args.query)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("query_get_outer_fragment_count", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_check_table_consistency(self, seqid, iprot, oprot):
        args = check_table_consistency_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = check_table_consistency_result()
        try:
            result.success = self._handler.check_table_consistency(args.session, args.table_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("check_table_consistency", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_start_query(self, seqid, iprot, oprot):
        args = start_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = start_query_result()
        try:
            result.success = self._handler.start_query(args.leaf_session, args.parent_session, args.query_ra, args.just_explain, args.outer_fragment_indices)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("start_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_execute_query_step(self, seqid, iprot, oprot):
        args = execute_query_step_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = execute_query_step_result()
        try:
            result.success = self._handler.execute_query_step(args.pending_query)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("execute_query_step", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_broadcast_serialized_rows(self, seqid, iprot, oprot):
        args = broadcast_serialized_rows_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = broadcast_serialized_rows_result()
        try:
            self._handler.broadcast_serialized_rows(args.serialized_rows, args.row_desc, args.query_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("broadcast_serialized_rows", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_start_render_query(self, seqid, iprot, oprot):
        args = start_render_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = start_render_query_result()
        try:
            result.success = self._handler.start_render_query(args.session, args.widget_id, args.node_idx, args.vega_json)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("start_render_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_execute_next_render_step(self, seqid, iprot, oprot):
        args = execute_next_render_step_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = execute_next_render_step_result()
        try:
            result.success = self._handler.execute_next_render_step(args.pending_render, args.merged_data)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("execute_next_render_step", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_insert_data(self, seqid, iprot, oprot):
        args = insert_data_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = insert_data_result()
        try:
            self._handler.insert_data(args.session, args.insert_data)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("insert_data", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_checkpoint(self, seqid, iprot, oprot):
        args = checkpoint_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = checkpoint_result()
        try:
            self._handler.checkpoint(args.session, args.db_id, args.table_id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("checkpoint", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_roles(self, seqid, iprot, oprot):
        args = get_roles_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_roles_result()
        try:
            result.success = self._handler.get_roles(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_roles", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_db_objects_for_grantee(self, seqid, iprot, oprot):
        args = get_db_objects_for_grantee_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_db_objects_for_grantee_result()
        try:
            result.success = self._handler.get_db_objects_for_grantee(args.session, args.roleName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_db_objects_for_grantee", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_db_object_privs(self, seqid, iprot, oprot):
        args = get_db_object_privs_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_db_object_privs_result()
        try:
            result.success = self._handler.get_db_object_privs(args.session, args.objectName, args.type)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_db_object_privs", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_all_roles_for_user(self, seqid, iprot, oprot):
        args = get_all_roles_for_user_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_all_roles_for_user_result()
        try:
            result.success = self._handler.get_all_roles_for_user(args.session, args.userName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_all_roles_for_user", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_has_role(self, seqid, iprot, oprot):
        args = has_role_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = has_role_result()
        try:
            result.success = self._handler.has_role(args.session, args.granteeName, args.roleName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("has_role", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_has_object_privilege(self, seqid, iprot, oprot):
        args = has_object_privilege_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = has_object_privilege_result()
        try:
            result.success = self._handler.has_object_privilege(args.session, args.granteeName, args.ObjectName, args.objectType, args.permissions)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("has_object_privilege", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_set_license_key(self, seqid, iprot, oprot):
        args = set_license_key_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = set_license_key_result()
        try:
            result.success = self._handler.set_license_key(args.session, args.key, args.nonce)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("set_license_key", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_license_claims(self, seqid, iprot, oprot):
        args = get_license_claims_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_license_claims_result()
        try:
            result.success = self._handler.get_license_claims(args.session, args.nonce)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_license_claims", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_device_parameters(self, seqid, iprot, oprot):
        args = get_device_parameters_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_device_parameters_result()
        try:
            result.success = self._handler.get_device_parameters(args.session)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_device_parameters", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_register_runtime_extension_functions(self, seqid, iprot, oprot):
        args = register_runtime_extension_functions_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = register_runtime_extension_functions_result()
        try:
            self._handler.register_runtime_extension_functions(args.session, args.udfs, args.udtfs, args.device_ir_map)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TOmniSciException as e:
            msg_type = TMessageType.REPLY
            result.e = e
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("register_runtime_extension_functions", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

# HELPER FUNCTIONS AND STRUCTURES


class connect_args(object):