From a439e3adee074022c4a119457524d36c183888d7 Mon Sep 17 00:00:00 2001 From: Vishal Anand <101251245+vishale6x@users.noreply.github.com> Date: Tue, 8 Aug 2023 19:28:03 +0530 Subject: [PATCH 1/4] Updated server files. --- e6x_engine.proto | 352 ++++++++++ e6xdb/e6xgrpc.py | 597 +++++++++++++++++ e6xdb/server/e6x_engine_pb2.py | 141 ++++ e6xdb/server/e6x_engine_pb2.pyi | 456 +++++++++++++ e6xdb/server/e6x_engine_pb2_grpc.py | 991 ++++++++++++++++++++++++++++ requirements.txt | 41 +- tests_grpc.py | 158 +++++ 7 files changed, 2716 insertions(+), 20 deletions(-) create mode 100644 e6x_engine.proto create mode 100644 e6xdb/e6xgrpc.py create mode 100644 e6xdb/server/e6x_engine_pb2.py create mode 100644 e6xdb/server/e6x_engine_pb2.pyi create mode 100644 e6xdb/server/e6x_engine_pb2_grpc.py create mode 100644 tests_grpc.py diff --git a/e6x_engine.proto b/e6x_engine.proto new file mode 100644 index 0000000..3970202 --- /dev/null +++ b/e6x_engine.proto @@ -0,0 +1,352 @@ +syntax = "proto3"; +option java_multiple_files = true; + + +message GFieldInfo { + string fieldName = 1; + string fieldType = 2; +} + + +message FailedSchemaElement +{ + string name = 1; + string type = 2; + string reason = 3; +} + +message GetAddCatalogsResponse +{ + string status = 1; + repeated FailedSchemaElement failures = 2; +} + +message CatalogResponse +{ + string name = 1; + bool isDefault = 2; +} + + +message ParameterValue +{ + sint32 index = 1; + string type = 2; + string value = 3; +} + +message ClearRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message ClearResponse{ +} + +message CancelQueryRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message CancelQueryResponse{ +} + +message ExplainRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message ExplainResponse{ + string explain = 1; +} + +message DryRunRequest{ + string engineIP = 1; + string sessionId = 2; + string schema = 3; + string queryString = 4; +} + +message DryRunResponse{ + string dryrunValue = 1; +} + +message DryRunRequestV2{ + string engineIP = 1; + string sessionId = 2; + string schema = 3; + string queryString = 4; + string catalog = 5; +} + +message ExplainAnalyzeRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message ExplainAnalyzeResponse{ + string explainAnalyze = 1; +} + +message PrepareStatementRequest{ + string sessionId = 1; + string schema = 2; + string queryString = 3; + string quoting = 4; +} + +message PrepareStatementV2Request{ + string sessionId = 1; + string schema = 2; + string queryString = 3; + string catalog = 4; + string quoting = 5; +} +message PrepareStatementResponse{ + string engineIP = 1; + string queryId = 2; +} + +message UserAccessInfo +{ + string uuid = 1; + string userName = 2; + repeated string tokens = 3; // lIST +} + +message ExecuteStatementRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} +message ExecuteStatementV2Request{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; + repeated ParameterValue params = 4; +} + +message ExecuteStatementResponse{ +} + +message GetNextResultRowRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message GetNextResultRowResponse{ + bytes resultRow = 2; +} + +message GetNextResultBatchRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message GetNextResultBatchResponse{ + bytes resultBatch = 2; +} + +message GetResultMetadataRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message GetResultMetadataResponse{ + bytes resultMetaData = 1; +} + +message AuthenticateRequest{ + string user = 1; + string password = 2; +} + +message AuthenticateResponse{ + string sessionId = 1; +} + +message GetTablesRequest{ + string sessionId = 1; + string schema = 2; +} + +message GetTablesV2Request{ + string sessionId = 1; + string schema = 2; + string catalog = 3; +} +message GetTablesResponse{ + repeated string tables = 1; +} + +message GetSchemaNamesRequest{ + string sessionId = 1; +} + +message GetSchemaNamesV2Request{ + string sessionId = 1; + string catalog = 2; +} + +message GetSchemaNamesResponse{ + repeated string schemas = 1; +} + +message GetColumnsRequest{ + string sessionId = 1; + string schema = 2; + string table = 3; +} +message GetColumnsV2Request{ + string sessionId = 1; + string schema = 2; + string table = 3; + string catalog = 4; +} + +message GetColumnsResponse{ + repeated GFieldInfo fieldInfo = 1; +} + +message StatusRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message StatusResponse +{ + bool status = 2; + sint64 rowCount = 3; +} + +message AddCatalogsRequest{ + string sessionId = 1; + string json = 2; +} + + +message UpdateUsersRequest{ + bytes users = 1; +} + +message UpdateUsersResponse{ +} + +message SetPropsRequest{ + string sessionId = 1; + string props = 2; +} +message SetPropsResponse{ +} + +message GetAddCatalogsRequest{ + string sessionId = 1; + +} + +message AddCatalogsResponse{ + +} + +message GetCatalogesRequest{ + +} + +message GetCatalogesResponse{ + repeated CatalogResponse catalogResponses = 1; +} + +message RefreshCatalogsRequest{ + string sessionId = 1; +} + +message RefreshCatalogsResponse{ +} + +message RemoteChunkRequest{ + string originalQueryId = 1; + string remoteQueryId = 2; + string sQueryHash = 3; +} + +message RemoteChunkResponse{ + string error = 1; + bytes chunk = 2; +} + +message ClearOrCancelQueryRequest{ + string engineIP = 1; + string sessionId = 2; + string queryId = 3; +} + +message ClearOrCancelQueryResponse{ +} + +service QueryEngineService { + rpc clear(ClearRequest) returns (ClearResponse); + + rpc cancelQuery(CancelQueryRequest) returns (CancelQueryResponse); + + rpc clearOrCancelQuery(ClearOrCancelQueryRequest) returns (ClearOrCancelQueryResponse); + + rpc explain(ExplainRequest) returns (ExplainResponse); + + rpc dryRun(DryRunRequest) returns (DryRunResponse); // Executor, Engine + + rpc dryRunV2(DryRunRequestV2) returns (DryRunResponse); + + rpc explainAnalyze(ExplainAnalyzeRequest) returns (ExplainAnalyzeResponse); + + rpc prepareStatement(PrepareStatementRequest) returns (PrepareStatementResponse); + + rpc prepareStatementV2(PrepareStatementV2Request) returns (PrepareStatementResponse); + + rpc executeStatement(ExecuteStatementRequest) returns (ExecuteStatementResponse); + + rpc executeStatementV2(ExecuteStatementV2Request) returns (ExecuteStatementResponse); + + rpc getNextResultRow(GetNextResultRowRequest) returns (GetNextResultRowResponse); + + rpc getNextResultBatch(GetNextResultBatchRequest) returns (GetNextResultBatchResponse); + + rpc getResultMetadata(GetResultMetadataRequest) returns (GetResultMetadataResponse); + + rpc authenticate(AuthenticateRequest) returns (AuthenticateResponse); + + rpc getTables(GetTablesRequest) returns (GetTablesResponse); + + rpc getTablesV2(GetTablesV2Request) returns (GetTablesResponse); + + rpc getSchemaNames(GetSchemaNamesRequest) returns (GetSchemaNamesResponse); + + rpc getSchemaNamesV2(GetSchemaNamesV2Request) returns (GetSchemaNamesResponse); + + rpc getColumns(GetColumnsRequest) returns (GetColumnsResponse); + + rpc getColumnsV2(GetColumnsV2Request) returns (GetColumnsResponse); + + rpc updateUsers(UpdateUsersRequest) returns (UpdateUsersResponse); + + rpc setProps(SetPropsRequest) returns (SetPropsResponse); + + rpc status(StatusRequest) returns (StatusResponse); + + rpc addCatalogs(AddCatalogsRequest) returns (AddCatalogsResponse); + + rpc getAddCatalogsResponse(GetAddCatalogsRequest) returns (GetAddCatalogsResponse); + + rpc getCataloges(GetCatalogesRequest) returns (GetCatalogesResponse); + + rpc getNextRemoteCachedChunk(RemoteChunkRequest) returns (RemoteChunkResponse); + + rpc refreshCatalogs(RefreshCatalogsRequest) returns (RefreshCatalogsResponse); +} \ No newline at end of file diff --git a/e6xdb/e6xgrpc.py b/e6xdb/e6xgrpc.py new file mode 100644 index 0000000..d3a5447 --- /dev/null +++ b/e6xdb/e6xgrpc.py @@ -0,0 +1,597 @@ +"""DB-API implementation backed by HiveServer2 (Thrift API) +See http://www.python.org/dev/peps/pep-0249/ +Many docstrings in this file are based on the PEP, which is in the public domain. +""" + +from __future__ import absolute_import +from __future__ import unicode_literals + +import datetime +# Make all exceptions visible in this e6xdb per DB-API +import logging +import re +import sys +from decimal import Decimal +from io import BytesIO +from ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED + +import grpc + +from e6xdb.common import DBAPITypeObject, ParamEscaper, DBAPICursor +from e6xdb.constants import * +from e6xdb.datainputstream import DataInputStream, get_query_columns_info, read_rows_from_batch, read_values_from_array +from e6xdb.server import e6x_engine_pb2_grpc, e6x_engine_pb2 +from e6xdb.typeId import * + +apilevel = '2.0' +threadsafety = 2 # Threads may share the e6xdb and connections. +paramstyle = 'pyformat' # Python extended format codes, e.g. ...WHERE name=%(name)s + +_logger = logging.getLogger(__name__) + +_TIMESTAMP_PATTERN = re.compile(r'(\d+-\d+-\d+ \d+:\d+:\d+(\.\d{,6})?)') + +ssl_cert_parameter_map = { + "none": CERT_NONE, + "optional": CERT_OPTIONAL, + "required": CERT_REQUIRED, +} + + +def _parse_timestamp(value): + if value: + match = _TIMESTAMP_PATTERN.match(value) + if match: + if match.group(2): + format = '%Y-%m-%d %H:%M:%S.%f' + # use the pattern to truncate the value + value = match.group() + else: + format = '%Y-%m-%d %H:%M:%S' + value = datetime.datetime.strptime(value, format) + else: + raise Exception( + 'Cannot convert "{}" into a datetime'.format(value)) + else: + value = None + return value + + +TYPES_CONVERTER = {"DECIMAL_TYPE": Decimal, + "TIMESTAMP_TYPE": _parse_timestamp} + + +class HiveParamEscaper(ParamEscaper): + def escape_string(self, item): + # backslashes and single quotes need to be escaped + # Need to decode UTF-8 because of old sqlalchemy. + # Newer SQLAlchemy checks dialect.supports_unicode_binds before encoding Unicode strings + # as byte strings. The old version always encodes Unicode as byte strings, which breaks + # string formatting here. + if isinstance(item, bytes): + item = item.decode('utf-8') + return "'{}'".format( + item + .replace('\\', '\\\\') + .replace("'", "\\'") + .replace('\r', '\\r') + .replace('\n', '\\n') + .replace('\t', '\\t') + ) + + +_escaper = HiveParamEscaper() + + +def connect(*args, **kwargs): + """Constructor for creating a connection to the database. See class :py:class:`Connection` for + arguments. + :returns: a :py:class:`Connection` object. + """ + return Connection(*args, **kwargs) + + +class Connection(object): + """Wraps a http e6xdb session""" + + def __init__( + self, + host=None, + port=None, + scheme='e6data', + username=None, + database='default', + auth=None, + configuration=None, + kerberos_service_name=None, + password=None, + check_hostname=None, + ssl_cert=None, + thrift_transport=None + ): + self.__username = username + self.__password = password + self._database = database + self._session_id = None + self._host = host + + if not self.__username or not self.__password: + raise ValueError("username or password cannot be empty.") + if port is None: + port = 9000 + self._port = port + self._channel = grpc.insecure_channel('{}:{}'.format(host, port)) + self._client = e6x_engine_pb2_grpc.QueryEngineServiceStub(self._channel) + + @property + def get_session_id(self): + """ + To get the session id, if user is not authorised, first authenticate the user. + """ + if not self._session_id: + try: + + authenticate_request = e6x_engine_pb2.AuthenticateRequest( + user=self.__username, + password=self.__password + ) + authenticate_response = self._client.authenticate(authenticate_request) + self._session_id = authenticate_response.sessionId + if not self._session_id: + raise ValueError("Invalid credentials.") + # self._client.setSchema(database) + except Exception as e: + self._channel.close() + raise e + return self._session_id + + def update_users(self, user_info): + self.client.updateUsers(userInfo=user_info) + + def set_prop_map(self, prop_map: str): + """ + To enable to disable the caches. + :param prop_map: To set engine props + """ + set_props_request = e6x_engine_pb2.SetPropsRequest(sessionId=self.get_session_id, props=prop_map) + self._client.setProps(set_props_request) + + def __enter__(self): + """Transport should already be opened by __init__""" + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + """Call close""" + self.close() + + def close(self): + if self._channel is not None: + self._channel.close() + self._channel = None + + def check_connection(self): + return self._channel is not None + + def clear(self, query_id, engine_ip=None): + clear_request = e6x_engine_pb2.ClearRequest( + sessionId=self.get_session_id, + queryId=query_id, + engineIP=engine_ip + ) + self._client.clear(clear_request) + self._session_id = None + + def reopen(self): + self._channel.close() + self._channel = grpc.insecure_channel('{}:{}'.format(self._host, self._port)) + + def query_cancel(self, engine_ip, query_id): + cancel_query_request = e6x_engine_pb2.CancelQueryRequest( + engineIP=engine_ip, + sessionId=self.get_session_id, + queryId=query_id + ) + self._client.cancelQuery(cancel_query_request) + + def dry_run(self, query): + dry_run_request = e6x_engine_pb2.DryRunRequest( + sessionId=self.get_session_id, + schema=self._database, + queryString=query + ) + dry_run_response = self._client.dryRun(dry_run_request) + return dry_run_response.dryrunValue + + def get_tables(self, database): + get_table_request = e6x_engine_pb2.GetTablesRequest(sessionId=self.get_session_id, schema=database) + get_table_response = self._client.getTables(get_table_request) + return get_table_response.tables + + def get_columns(self, database, table): + get_columns_request = e6x_engine_pb2.GetColumnsRequest( + sessionId=self.get_session_id, + schema=database, + table=table + ) + get_columns_response = self._client.getColumns(get_columns_request) + return get_columns_response.fieldInfo + + def get_schema_names(self): + get_schema_request = e6x_engine_pb2.GetSchemaNamesRequest(sessionId=self.get_session_id) + get_schema_response = self._client.getSchemaNames(get_schema_request) + return get_schema_response.schemas + + def commit(self): + """We do not support transactions, so this does nothing.""" + pass + + def cursor(self, db_name=None, catalog_name=None): + """Return a new :py:class:`Cursor` object using the connection.""" + return Cursor(self, database=db_name, catalog_name=catalog_name) + + def rollback(self): + raise Exception("e6xdb does not support transactions") # pragma: no cover + + @property + def client(self): + return self._client + + +class Cursor(DBAPICursor): + """These objects represent a database cursor, which is used to manage the context of a fetch + operation. + Cursors are not isolated, i.e., any changes done to the database by a cursor are immediately + visible by other cursors or connections. + """ + rows_count = 0 + + def __init__(self, connection: Connection, arraysize=1000, database=None, catalog_name=None): + super(Cursor, self).__init__() + self._arraysize = arraysize + self.connection = connection + self._data = None + self._query_columns_description = None + self._is_metadata_updated = False + self._description = None + self._query_id = None + self._engine_ip = None + self._batch = list() + self._rowcount = 0 + self._database = self.connection._database if database is None else database + self._catalog_name = catalog_name + + def _reset_state(self): + """Reset state about the previous query in preparation for running another query""" + pass + + @property + def arraysize(self): + return self._arraysize + + @arraysize.setter + def arraysize(self, value): + """Array size cannot be None, and should be an integer""" + default_arraysize = 1000 + try: + self._arraysize = int(value) or default_arraysize + except TypeError: + self._arraysize = default_arraysize + + @property + def description(self): + """This read-only attribute is a sequence of 7-item sequences. + Each of these sequences contains information describing one result column: + - name + - type_code + - display_size (None in current implementation) + - internal_size (None in current implementation) + - precision (None in current implementation) + - scale (None in current implementation) + - null_ok (always True in current implementation) + This attribute will be ``None`` for operations that do not return rows or if the cursor has + not had an operation invoked via the :py:meth:`execute` method yet. + The ``type_code`` can be interpreted by comparing it to the Type Objects specified in the + section below. + """ + if self._description is None: + self._description = [] + for col in self._query_columns_description: + type_code = col.get_field_type() + column_name = col.get_name() + self._description.append(( + column_name, + type_code, + None, None, None, None, True + )) + return self._description + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + + def close(self): + """Close the operation handle""" + # self.connection.close() + self._arraysize = None + self.connection = None + self._data = None + self._engine_ip = None + self._query_columns_description = None + self._description = None + self._query_id = None + self._batch = None + self._rowcount = None + self._database = None + + def get_tables(self): + schema = self.connection._database + return self.connection.get_tables(database=schema) + + def get_columns(self, table): + schema = self.connection._database + return self.connection.get_columns(database=schema, table=table) + + def clear(self): + """Clears the tmp data""" + # self.connection.clear( + # query_id=self._query_id, + # engine_ip=self._engine_ip + # ) + clear_request = e6x_engine_pb2.ClearRequest( + sessionId=self.connection.get_session_id, + queryId=self._query_id, + engineIP=self._engine_ip + ) + response = self.connection.client.clear(clear_request) + print(response) + + def cancel(self, query_id): + _logger.info("Cancelling query") + self.connection.query_cancel(engine_ip=self._engine_ip, query_id=query_id) + + def status(self, query_id): + client = self.connection.client + return client.status(self.connection.get_session_id, query_id) + + def execute(self, operation, parameters=None, **kwargs): + """Prepare and execute a database operation (query or command). + Return values are not defined. + """ + """ + Semicolon is now not supported. So removing it from query end. + """ + if operation.endswith(';'): + operation = operation[:-1] + + # Prepare statement + if parameters is None: + sql = operation + else: + sql = operation % _escaper.escape_args(parameters) + + client = self.connection.client + if not self._catalog_name: + prepare_statement_request = e6x_engine_pb2.PrepareStatementRequest( + sessionId=self.connection.get_session_id, + schema=self._database, + queryString=sql + ) + prepare_statement_response = client.prepareStatement(prepare_statement_request) + + self._query_id = prepare_statement_response.queryId + self._engine_ip = prepare_statement_response.engineIP + execute_statement_request = e6x_engine_pb2.ExecuteStatementRequest( + engineIP=self._engine_ip, + sessionId=self.connection.get_session_id, + queryId=self._query_id + ) + execute_statement_response = client.executeStatement(execute_statement_request) + else: + prepare_statement_request = e6x_engine_pb2.PrepareStatementV2Request( + sessionId=self.connection.get_session_id, + schema=self._database, + queryString=sql, + catalog=self._catalog_name, + ) + prepare_statement_response = client.prepareStatementV2(prepare_statement_request) + + self._query_id = prepare_statement_response.queryId + self._engine_ip = prepare_statement_response.engineIP + execute_statement_request = e6x_engine_pb2.ExecuteStatementV2Request( + engineIP=self._engine_ip, + sessionId=self.connection.get_session_id, + queryId=self._query_id + ) + execute_statement_response = client.executeStatementV2(execute_statement_request) + self.update_mete_data() + return self._query_id + + def rowcount(self): + return self._rowcount + + def update_mete_data(self): + result_meta_data_request = e6x_engine_pb2.GetResultMetadataRequest( + engineIP=self._engine_ip, + sessionId=self.connection.get_session_id, + queryId=self._query_id + ) + get_result_metadata_response = self.connection.client.getResultMetadata(result_meta_data_request) + buffer = BytesIO(get_result_metadata_response.resultMetaData) + self._rowcount, self._query_columns_description = get_query_columns_info(buffer) + + def _fetch_more(self): + batch_size = self._arraysize + self._data = list() + for i in range(batch_size): + rows = self.fetch_batch() + if rows is None: + return + self._data = self._data + rows + return self._data + + def _fetch_all(self): + self._data = list() + while True: + rows = self.fetch_batch() + if rows is None: + break + self._data = self._data + rows + rows = self._data + self._data = None + return rows + + def fetchall_buffer(self, query_id=None): + if query_id: + self._query_id = query_id + while True: + rows = self.fetch_batch() + if not rows: + return + yield rows + + def fetch_batch(self): + # _logger.debug("fetching next batch from e6data") + client = self.connection.client + get_next_result_batch_request = e6x_engine_pb2.GetNextResultBatchRequest( + engineIP=self._engine_ip, + sessionId=self.connection.get_session_id, + queryId=self._query_id + ) + get_next_result_batch_response = client.getNextResultBatch(get_next_result_batch_request) + buffer = get_next_result_batch_response.resultBatch + if not self._is_metadata_updated: + self.update_mete_data() + self._is_metadata_updated = True + if not buffer: + return None + buffer = BytesIO(buffer) + dis = DataInputStream(buffer) + # one batch retrieves the predefined set of rows + return read_rows_from_batch(self._query_columns_description, dis) + + def fetchall(self): + return self._fetch_all() + + def fetchmany(self, size=None): + # _logger.info("fetching all from overriden method") + if size is None: + size = self.arraysize + if self._data is None: + self._data = list() + while len(self._data) < size: + # _logger.info("fetching next batch from fetch many") + rows = self.fetch_batch() + if rows is None: + break + self._data += rows + _logger.info(len(self._data)) + if len(self._data) <= size: + rows = self._data + self._data = None + return rows + rows = self._data[:size] + self._data = self._data[size:] + return rows + + def fetchone(self): + # _logger.info("fetch One returning the batch itself which is limited by predefined no.of rows") + rows_to_return = [] + client = self.connection.client + get_next_result_row_request = e6x_engine_pb2.GetNextResultRowRequest( + engineIP=self._engine_ip, + sessionId=self.connection.get_session_id, + queryId=self._query_id + ) + get_next_result_row_response = client.getNextResultRow(get_next_result_row_request) + buffer = get_next_result_row_response.resultRow + if not self._is_metadata_updated: + self.update_mete_data() + self._is_metadata_updated = True + if not buffer: + return None + buffer = BytesIO(buffer) + dis = DataInputStream(buffer) + rows_to_return.append(read_values_from_array(self._query_columns_description, dis)) + return rows_to_return + + def explain(self): + explain_request = e6x_engine_pb2.ExplainRequest( + engineIP=self._engine_ip, + sessionId=self.connection.get_session_id, + queryId=self._query_id + ) + explain_response = self.connection.client.explain(explain_request) + return explain_response.explain + + def explain_analyse(self): + explain_analyze_request = e6x_engine_pb2.ExplainAnalyzeRequest( + engineIP=self._engine_ip, + sessionId=self.connection.get_session_id, + queryId=self._query_id + ) + explain_analyze_response = self.connection.client.explainAnalyze(explain_analyze_request) + return explain_analyze_response.explainAnalyze + + +def poll(self, get_progress_update=True): + """Poll for and return the raw status data provided by the Hive Thrift REST API. + :returns: ``ttypes.TGetOperationStatusResp`` + :raises: ``ProgrammingError`` when no query has been started + .. note:: + This is not a part of DB-API. + """ + pass + + +def fetch_logs(self): + """Retrieve the logs produced by the execution of the query. + Can be called multiple times to fetch the logs produced after the previous call. + :returns: list + :raises: ``ProgrammingError`` when no query has been started + .. note:: + This is not a part of DB-API. + """ + pass + + +class Error(Exception): + pass + + +# +# Type Objects and Constructors +# + +for type_id in PRIMITIVE_TYPES: + name = TypeId._VALUES_TO_NAMES[type_id] + setattr(sys.modules[__name__], name, DBAPITypeObject([name])) + +if __name__ == '__main__': + query = 'select * from catalog_sales' + conn = Connection( + host='localhost', + port=4000, + username='shubham@e6x.io', + password='w3aSShTYPGt12Z8QuCXcxuAggKB4INyEzDwg1WFj0THDgJRMuwryt5dt', + database='tpcds_1000' + ) + cursor = conn.cursor( + catalog_name='perfhive', + db_name='tpcds_1000' + ) + qid = cursor.execute(query) + print(qid, qid) + # print(cursor.cancel(qid)) + for i in cursor.fetchall_buffer(): + print(sys.getsizeof(i)) + print(cursor.cancel(qid)) + break + # print('Response size', sys.getsizeof(res)) + try: + cursor.clear() + except Exception as e: + print(e) + cursor.close() + conn.close() diff --git a/e6xdb/server/e6x_engine_pb2.py b/e6xdb/server/e6x_engine_pb2.py new file mode 100644 index 0000000..79b91e8 --- /dev/null +++ b/e6xdb/server/e6x_engine_pb2.py @@ -0,0 +1,141 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: e6x_engine.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10\x65\x36x_engine.proto\"2\n\nGFieldInfo\x12\x11\n\tfieldName\x18\x01 \x01(\t\x12\x11\n\tfieldType\x18\x02 \x01(\t\"A\n\x13\x46\x61iledSchemaElement\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\"P\n\x16GetAddCatalogsResponse\x12\x0e\n\x06status\x18\x01 \x01(\t\x12&\n\x08\x66\x61ilures\x18\x02 \x03(\x0b\x32\x14.FailedSchemaElement\"2\n\x0f\x43\x61talogResponse\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x11\n\tisDefault\x18\x02 \x01(\x08\"<\n\x0eParameterValue\x12\r\n\x05index\x18\x01 \x01(\x11\x12\x0c\n\x04type\x18\x02 \x01(\t\x12\r\n\x05value\x18\x03 \x01(\t\"D\n\x0c\x43learRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"\x0f\n\rClearResponse\"J\n\x12\x43\x61ncelQueryRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"\x15\n\x13\x43\x61ncelQueryResponse\"F\n\x0e\x45xplainRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"\"\n\x0f\x45xplainResponse\x12\x0f\n\x07\x65xplain\x18\x01 \x01(\t\"Y\n\rDryRunRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0e\n\x06schema\x18\x03 \x01(\t\x12\x13\n\x0bqueryString\x18\x04 \x01(\t\"%\n\x0e\x44ryRunResponse\x12\x13\n\x0b\x64ryrunValue\x18\x01 \x01(\t\"l\n\x0f\x44ryRunRequestV2\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0e\n\x06schema\x18\x03 \x01(\t\x12\x13\n\x0bqueryString\x18\x04 \x01(\t\x12\x0f\n\x07\x63\x61talog\x18\x05 \x01(\t\"M\n\x15\x45xplainAnalyzeRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"0\n\x16\x45xplainAnalyzeResponse\x12\x16\n\x0e\x65xplainAnalyze\x18\x01 \x01(\t\"b\n\x17PrepareStatementRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0e\n\x06schema\x18\x02 \x01(\t\x12\x13\n\x0bqueryString\x18\x03 \x01(\t\x12\x0f\n\x07quoting\x18\x04 \x01(\t\"u\n\x19PrepareStatementV2Request\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0e\n\x06schema\x18\x02 \x01(\t\x12\x13\n\x0bqueryString\x18\x03 \x01(\t\x12\x0f\n\x07\x63\x61talog\x18\x04 \x01(\t\x12\x0f\n\x07quoting\x18\x05 \x01(\t\"=\n\x18PrepareStatementResponse\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x0f\n\x07queryId\x18\x02 \x01(\t\"@\n\x0eUserAccessInfo\x12\x0c\n\x04uuid\x18\x01 \x01(\t\x12\x10\n\x08userName\x18\x02 \x01(\t\x12\x0e\n\x06tokens\x18\x03 \x03(\t\"O\n\x17\x45xecuteStatementRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"r\n\x19\x45xecuteStatementV2Request\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\x12\x1f\n\x06params\x18\x04 \x03(\x0b\x32\x0f.ParameterValue\"\x1a\n\x18\x45xecuteStatementResponse\"O\n\x17GetNextResultRowRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"-\n\x18GetNextResultRowResponse\x12\x11\n\tresultRow\x18\x02 \x01(\x0c\"Q\n\x19GetNextResultBatchRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"1\n\x1aGetNextResultBatchResponse\x12\x13\n\x0bresultBatch\x18\x02 \x01(\x0c\"P\n\x18GetResultMetadataRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"3\n\x19GetResultMetadataResponse\x12\x16\n\x0eresultMetaData\x18\x01 \x01(\x0c\"5\n\x13\x41uthenticateRequest\x12\x0c\n\x04user\x18\x01 \x01(\t\x12\x10\n\x08password\x18\x02 \x01(\t\")\n\x14\x41uthenticateResponse\x12\x11\n\tsessionId\x18\x01 \x01(\t\"5\n\x10GetTablesRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0e\n\x06schema\x18\x02 \x01(\t\"H\n\x12GetTablesV2Request\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0e\n\x06schema\x18\x02 \x01(\t\x12\x0f\n\x07\x63\x61talog\x18\x03 \x01(\t\"#\n\x11GetTablesResponse\x12\x0e\n\x06tables\x18\x01 \x03(\t\"*\n\x15GetSchemaNamesRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\"=\n\x17GetSchemaNamesV2Request\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0f\n\x07\x63\x61talog\x18\x02 \x01(\t\")\n\x16GetSchemaNamesResponse\x12\x0f\n\x07schemas\x18\x01 \x03(\t\"E\n\x11GetColumnsRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0e\n\x06schema\x18\x02 \x01(\t\x12\r\n\x05table\x18\x03 \x01(\t\"X\n\x13GetColumnsV2Request\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0e\n\x06schema\x18\x02 \x01(\t\x12\r\n\x05table\x18\x03 \x01(\t\x12\x0f\n\x07\x63\x61talog\x18\x04 \x01(\t\"4\n\x12GetColumnsResponse\x12\x1e\n\tfieldInfo\x18\x01 \x03(\x0b\x32\x0b.GFieldInfo\"E\n\rStatusRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"2\n\x0eStatusResponse\x12\x0e\n\x06status\x18\x02 \x01(\x08\x12\x10\n\x08rowCount\x18\x03 \x01(\x12\"5\n\x12\x41\x64\x64\x43\x61talogsRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\x0c\n\x04json\x18\x02 \x01(\t\"#\n\x12UpdateUsersRequest\x12\r\n\x05users\x18\x01 \x01(\x0c\"\x15\n\x13UpdateUsersResponse\"3\n\x0fSetPropsRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\x12\r\n\x05props\x18\x02 \x01(\t\"\x12\n\x10SetPropsResponse\"*\n\x15GetAddCatalogsRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\"\x15\n\x13\x41\x64\x64\x43\x61talogsResponse\"\x15\n\x13GetCatalogesRequest\"B\n\x14GetCatalogesResponse\x12*\n\x10\x63\x61talogResponses\x18\x01 \x03(\x0b\x32\x10.CatalogResponse\"+\n\x16RefreshCatalogsRequest\x12\x11\n\tsessionId\x18\x01 \x01(\t\"\x19\n\x17RefreshCatalogsResponse\"X\n\x12RemoteChunkRequest\x12\x17\n\x0foriginalQueryId\x18\x01 \x01(\t\x12\x15\n\rremoteQueryId\x18\x02 \x01(\t\x12\x12\n\nsQueryHash\x18\x03 \x01(\t\"3\n\x13RemoteChunkResponse\x12\r\n\x05\x65rror\x18\x01 \x01(\t\x12\r\n\x05\x63hunk\x18\x02 \x01(\x0c\"Q\n\x19\x43learOrCancelQueryRequest\x12\x10\n\x08\x65ngineIP\x18\x01 \x01(\t\x12\x11\n\tsessionId\x18\x02 \x01(\t\x12\x0f\n\x07queryId\x18\x03 \x01(\t\"\x1c\n\x1a\x43learOrCancelQueryResponse2\xaa\x0e\n\x12QueryEngineService\x12&\n\x05\x63lear\x12\r.ClearRequest\x1a\x0e.ClearResponse\x12\x38\n\x0b\x63\x61ncelQuery\x12\x13.CancelQueryRequest\x1a\x14.CancelQueryResponse\x12M\n\x12\x63learOrCancelQuery\x12\x1a.ClearOrCancelQueryRequest\x1a\x1b.ClearOrCancelQueryResponse\x12,\n\x07\x65xplain\x12\x0f.ExplainRequest\x1a\x10.ExplainResponse\x12)\n\x06\x64ryRun\x12\x0e.DryRunRequest\x1a\x0f.DryRunResponse\x12-\n\x08\x64ryRunV2\x12\x10.DryRunRequestV2\x1a\x0f.DryRunResponse\x12\x41\n\x0e\x65xplainAnalyze\x12\x16.ExplainAnalyzeRequest\x1a\x17.ExplainAnalyzeResponse\x12G\n\x10prepareStatement\x12\x18.PrepareStatementRequest\x1a\x19.PrepareStatementResponse\x12K\n\x12prepareStatementV2\x12\x1a.PrepareStatementV2Request\x1a\x19.PrepareStatementResponse\x12G\n\x10\x65xecuteStatement\x12\x18.ExecuteStatementRequest\x1a\x19.ExecuteStatementResponse\x12K\n\x12\x65xecuteStatementV2\x12\x1a.ExecuteStatementV2Request\x1a\x19.ExecuteStatementResponse\x12G\n\x10getNextResultRow\x12\x18.GetNextResultRowRequest\x1a\x19.GetNextResultRowResponse\x12M\n\x12getNextResultBatch\x12\x1a.GetNextResultBatchRequest\x1a\x1b.GetNextResultBatchResponse\x12J\n\x11getResultMetadata\x12\x19.GetResultMetadataRequest\x1a\x1a.GetResultMetadataResponse\x12;\n\x0c\x61uthenticate\x12\x14.AuthenticateRequest\x1a\x15.AuthenticateResponse\x12\x32\n\tgetTables\x12\x11.GetTablesRequest\x1a\x12.GetTablesResponse\x12\x36\n\x0bgetTablesV2\x12\x13.GetTablesV2Request\x1a\x12.GetTablesResponse\x12\x41\n\x0egetSchemaNames\x12\x16.GetSchemaNamesRequest\x1a\x17.GetSchemaNamesResponse\x12\x45\n\x10getSchemaNamesV2\x12\x18.GetSchemaNamesV2Request\x1a\x17.GetSchemaNamesResponse\x12\x35\n\ngetColumns\x12\x12.GetColumnsRequest\x1a\x13.GetColumnsResponse\x12\x39\n\x0cgetColumnsV2\x12\x14.GetColumnsV2Request\x1a\x13.GetColumnsResponse\x12\x38\n\x0bupdateUsers\x12\x13.UpdateUsersRequest\x1a\x14.UpdateUsersResponse\x12/\n\x08setProps\x12\x10.SetPropsRequest\x1a\x11.SetPropsResponse\x12)\n\x06status\x12\x0e.StatusRequest\x1a\x0f.StatusResponse\x12\x38\n\x0b\x61\x64\x64\x43\x61talogs\x12\x13.AddCatalogsRequest\x1a\x14.AddCatalogsResponse\x12I\n\x16getAddCatalogsResponse\x12\x16.GetAddCatalogsRequest\x1a\x17.GetAddCatalogsResponse\x12;\n\x0cgetCataloges\x12\x14.GetCatalogesRequest\x1a\x15.GetCatalogesResponse\x12\x45\n\x18getNextRemoteCachedChunk\x12\x13.RemoteChunkRequest\x1a\x14.RemoteChunkResponse\x12\x44\n\x0frefreshCatalogs\x12\x17.RefreshCatalogsRequest\x1a\x18.RefreshCatalogsResponseB\x02P\x01\x62\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'e6x_engine_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'P\001' + _globals['_GFIELDINFO']._serialized_start=20 + _globals['_GFIELDINFO']._serialized_end=70 + _globals['_FAILEDSCHEMAELEMENT']._serialized_start=72 + _globals['_FAILEDSCHEMAELEMENT']._serialized_end=137 + _globals['_GETADDCATALOGSRESPONSE']._serialized_start=139 + _globals['_GETADDCATALOGSRESPONSE']._serialized_end=219 + _globals['_CATALOGRESPONSE']._serialized_start=221 + _globals['_CATALOGRESPONSE']._serialized_end=271 + _globals['_PARAMETERVALUE']._serialized_start=273 + _globals['_PARAMETERVALUE']._serialized_end=333 + _globals['_CLEARREQUEST']._serialized_start=335 + _globals['_CLEARREQUEST']._serialized_end=403 + _globals['_CLEARRESPONSE']._serialized_start=405 + _globals['_CLEARRESPONSE']._serialized_end=420 + _globals['_CANCELQUERYREQUEST']._serialized_start=422 + _globals['_CANCELQUERYREQUEST']._serialized_end=496 + _globals['_CANCELQUERYRESPONSE']._serialized_start=498 + _globals['_CANCELQUERYRESPONSE']._serialized_end=519 + _globals['_EXPLAINREQUEST']._serialized_start=521 + _globals['_EXPLAINREQUEST']._serialized_end=591 + _globals['_EXPLAINRESPONSE']._serialized_start=593 + _globals['_EXPLAINRESPONSE']._serialized_end=627 + _globals['_DRYRUNREQUEST']._serialized_start=629 + _globals['_DRYRUNREQUEST']._serialized_end=718 + _globals['_DRYRUNRESPONSE']._serialized_start=720 + _globals['_DRYRUNRESPONSE']._serialized_end=757 + _globals['_DRYRUNREQUESTV2']._serialized_start=759 + _globals['_DRYRUNREQUESTV2']._serialized_end=867 + _globals['_EXPLAINANALYZEREQUEST']._serialized_start=869 + _globals['_EXPLAINANALYZEREQUEST']._serialized_end=946 + _globals['_EXPLAINANALYZERESPONSE']._serialized_start=948 + _globals['_EXPLAINANALYZERESPONSE']._serialized_end=996 + _globals['_PREPARESTATEMENTREQUEST']._serialized_start=998 + _globals['_PREPARESTATEMENTREQUEST']._serialized_end=1096 + _globals['_PREPARESTATEMENTV2REQUEST']._serialized_start=1098 + _globals['_PREPARESTATEMENTV2REQUEST']._serialized_end=1215 + _globals['_PREPARESTATEMENTRESPONSE']._serialized_start=1217 + _globals['_PREPARESTATEMENTRESPONSE']._serialized_end=1278 + _globals['_USERACCESSINFO']._serialized_start=1280 + _globals['_USERACCESSINFO']._serialized_end=1344 + _globals['_EXECUTESTATEMENTREQUEST']._serialized_start=1346 + _globals['_EXECUTESTATEMENTREQUEST']._serialized_end=1425 + _globals['_EXECUTESTATEMENTV2REQUEST']._serialized_start=1427 + _globals['_EXECUTESTATEMENTV2REQUEST']._serialized_end=1541 + _globals['_EXECUTESTATEMENTRESPONSE']._serialized_start=1543 + _globals['_EXECUTESTATEMENTRESPONSE']._serialized_end=1569 + _globals['_GETNEXTRESULTROWREQUEST']._serialized_start=1571 + _globals['_GETNEXTRESULTROWREQUEST']._serialized_end=1650 + _globals['_GETNEXTRESULTROWRESPONSE']._serialized_start=1652 + _globals['_GETNEXTRESULTROWRESPONSE']._serialized_end=1697 + _globals['_GETNEXTRESULTBATCHREQUEST']._serialized_start=1699 + _globals['_GETNEXTRESULTBATCHREQUEST']._serialized_end=1780 + _globals['_GETNEXTRESULTBATCHRESPONSE']._serialized_start=1782 + _globals['_GETNEXTRESULTBATCHRESPONSE']._serialized_end=1831 + _globals['_GETRESULTMETADATAREQUEST']._serialized_start=1833 + _globals['_GETRESULTMETADATAREQUEST']._serialized_end=1913 + _globals['_GETRESULTMETADATARESPONSE']._serialized_start=1915 + _globals['_GETRESULTMETADATARESPONSE']._serialized_end=1966 + _globals['_AUTHENTICATEREQUEST']._serialized_start=1968 + _globals['_AUTHENTICATEREQUEST']._serialized_end=2021 + _globals['_AUTHENTICATERESPONSE']._serialized_start=2023 + _globals['_AUTHENTICATERESPONSE']._serialized_end=2064 + _globals['_GETTABLESREQUEST']._serialized_start=2066 + _globals['_GETTABLESREQUEST']._serialized_end=2119 + _globals['_GETTABLESV2REQUEST']._serialized_start=2121 + _globals['_GETTABLESV2REQUEST']._serialized_end=2193 + _globals['_GETTABLESRESPONSE']._serialized_start=2195 + _globals['_GETTABLESRESPONSE']._serialized_end=2230 + _globals['_GETSCHEMANAMESREQUEST']._serialized_start=2232 + _globals['_GETSCHEMANAMESREQUEST']._serialized_end=2274 + _globals['_GETSCHEMANAMESV2REQUEST']._serialized_start=2276 + _globals['_GETSCHEMANAMESV2REQUEST']._serialized_end=2337 + _globals['_GETSCHEMANAMESRESPONSE']._serialized_start=2339 + _globals['_GETSCHEMANAMESRESPONSE']._serialized_end=2380 + _globals['_GETCOLUMNSREQUEST']._serialized_start=2382 + _globals['_GETCOLUMNSREQUEST']._serialized_end=2451 + _globals['_GETCOLUMNSV2REQUEST']._serialized_start=2453 + _globals['_GETCOLUMNSV2REQUEST']._serialized_end=2541 + _globals['_GETCOLUMNSRESPONSE']._serialized_start=2543 + _globals['_GETCOLUMNSRESPONSE']._serialized_end=2595 + _globals['_STATUSREQUEST']._serialized_start=2597 + _globals['_STATUSREQUEST']._serialized_end=2666 + _globals['_STATUSRESPONSE']._serialized_start=2668 + _globals['_STATUSRESPONSE']._serialized_end=2718 + _globals['_ADDCATALOGSREQUEST']._serialized_start=2720 + _globals['_ADDCATALOGSREQUEST']._serialized_end=2773 + _globals['_UPDATEUSERSREQUEST']._serialized_start=2775 + _globals['_UPDATEUSERSREQUEST']._serialized_end=2810 + _globals['_UPDATEUSERSRESPONSE']._serialized_start=2812 + _globals['_UPDATEUSERSRESPONSE']._serialized_end=2833 + _globals['_SETPROPSREQUEST']._serialized_start=2835 + _globals['_SETPROPSREQUEST']._serialized_end=2886 + _globals['_SETPROPSRESPONSE']._serialized_start=2888 + _globals['_SETPROPSRESPONSE']._serialized_end=2906 + _globals['_GETADDCATALOGSREQUEST']._serialized_start=2908 + _globals['_GETADDCATALOGSREQUEST']._serialized_end=2950 + _globals['_ADDCATALOGSRESPONSE']._serialized_start=2952 + _globals['_ADDCATALOGSRESPONSE']._serialized_end=2973 + _globals['_GETCATALOGESREQUEST']._serialized_start=2975 + _globals['_GETCATALOGESREQUEST']._serialized_end=2996 + _globals['_GETCATALOGESRESPONSE']._serialized_start=2998 + _globals['_GETCATALOGESRESPONSE']._serialized_end=3064 + _globals['_REFRESHCATALOGSREQUEST']._serialized_start=3066 + _globals['_REFRESHCATALOGSREQUEST']._serialized_end=3109 + _globals['_REFRESHCATALOGSRESPONSE']._serialized_start=3111 + _globals['_REFRESHCATALOGSRESPONSE']._serialized_end=3136 + _globals['_REMOTECHUNKREQUEST']._serialized_start=3138 + _globals['_REMOTECHUNKREQUEST']._serialized_end=3226 + _globals['_REMOTECHUNKRESPONSE']._serialized_start=3228 + _globals['_REMOTECHUNKRESPONSE']._serialized_end=3279 + _globals['_CLEARORCANCELQUERYREQUEST']._serialized_start=3281 + _globals['_CLEARORCANCELQUERYREQUEST']._serialized_end=3362 + _globals['_CLEARORCANCELQUERYRESPONSE']._serialized_start=3364 + _globals['_CLEARORCANCELQUERYRESPONSE']._serialized_end=3392 + _globals['_QUERYENGINESERVICE']._serialized_start=3395 + _globals['_QUERYENGINESERVICE']._serialized_end=5229 +# @@protoc_insertion_point(module_scope) diff --git a/e6xdb/server/e6x_engine_pb2.pyi b/e6xdb/server/e6x_engine_pb2.pyi new file mode 100644 index 0000000..aa29339 --- /dev/null +++ b/e6xdb/server/e6x_engine_pb2.pyi @@ -0,0 +1,456 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class GFieldInfo(_message.Message): + __slots__ = ["fieldName", "fieldType"] + FIELDNAME_FIELD_NUMBER: _ClassVar[int] + FIELDTYPE_FIELD_NUMBER: _ClassVar[int] + fieldName: str + fieldType: str + def __init__(self, fieldName: _Optional[str] = ..., fieldType: _Optional[str] = ...) -> None: ... + +class FailedSchemaElement(_message.Message): + __slots__ = ["name", "type", "reason"] + NAME_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + name: str + type: str + reason: str + def __init__(self, name: _Optional[str] = ..., type: _Optional[str] = ..., reason: _Optional[str] = ...) -> None: ... + +class GetAddCatalogsResponse(_message.Message): + __slots__ = ["status", "failures"] + STATUS_FIELD_NUMBER: _ClassVar[int] + FAILURES_FIELD_NUMBER: _ClassVar[int] + status: str + failures: _containers.RepeatedCompositeFieldContainer[FailedSchemaElement] + def __init__(self, status: _Optional[str] = ..., failures: _Optional[_Iterable[_Union[FailedSchemaElement, _Mapping]]] = ...) -> None: ... + +class CatalogResponse(_message.Message): + __slots__ = ["name", "isDefault"] + NAME_FIELD_NUMBER: _ClassVar[int] + ISDEFAULT_FIELD_NUMBER: _ClassVar[int] + name: str + isDefault: bool + def __init__(self, name: _Optional[str] = ..., isDefault: bool = ...) -> None: ... + +class ParameterValue(_message.Message): + __slots__ = ["index", "type", "value"] + INDEX_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + index: int + type: str + value: str + def __init__(self, index: _Optional[int] = ..., type: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + +class ClearRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class ClearResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class CancelQueryRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class CancelQueryResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class ExplainRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class ExplainResponse(_message.Message): + __slots__ = ["explain"] + EXPLAIN_FIELD_NUMBER: _ClassVar[int] + explain: str + def __init__(self, explain: _Optional[str] = ...) -> None: ... + +class DryRunRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "schema", "queryString"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + QUERYSTRING_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + schema: str + queryString: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., schema: _Optional[str] = ..., queryString: _Optional[str] = ...) -> None: ... + +class DryRunResponse(_message.Message): + __slots__ = ["dryrunValue"] + DRYRUNVALUE_FIELD_NUMBER: _ClassVar[int] + dryrunValue: str + def __init__(self, dryrunValue: _Optional[str] = ...) -> None: ... + +class DryRunRequestV2(_message.Message): + __slots__ = ["engineIP", "sessionId", "schema", "queryString", "catalog"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + QUERYSTRING_FIELD_NUMBER: _ClassVar[int] + CATALOG_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + schema: str + queryString: str + catalog: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., schema: _Optional[str] = ..., queryString: _Optional[str] = ..., catalog: _Optional[str] = ...) -> None: ... + +class ExplainAnalyzeRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class ExplainAnalyzeResponse(_message.Message): + __slots__ = ["explainAnalyze"] + EXPLAINANALYZE_FIELD_NUMBER: _ClassVar[int] + explainAnalyze: str + def __init__(self, explainAnalyze: _Optional[str] = ...) -> None: ... + +class PrepareStatementRequest(_message.Message): + __slots__ = ["sessionId", "schema", "queryString", "quoting"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + QUERYSTRING_FIELD_NUMBER: _ClassVar[int] + QUOTING_FIELD_NUMBER: _ClassVar[int] + sessionId: str + schema: str + queryString: str + quoting: str + def __init__(self, sessionId: _Optional[str] = ..., schema: _Optional[str] = ..., queryString: _Optional[str] = ..., quoting: _Optional[str] = ...) -> None: ... + +class PrepareStatementV2Request(_message.Message): + __slots__ = ["sessionId", "schema", "queryString", "catalog", "quoting"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + QUERYSTRING_FIELD_NUMBER: _ClassVar[int] + CATALOG_FIELD_NUMBER: _ClassVar[int] + QUOTING_FIELD_NUMBER: _ClassVar[int] + sessionId: str + schema: str + queryString: str + catalog: str + quoting: str + def __init__(self, sessionId: _Optional[str] = ..., schema: _Optional[str] = ..., queryString: _Optional[str] = ..., catalog: _Optional[str] = ..., quoting: _Optional[str] = ...) -> None: ... + +class PrepareStatementResponse(_message.Message): + __slots__ = ["engineIP", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class UserAccessInfo(_message.Message): + __slots__ = ["uuid", "userName", "tokens"] + UUID_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + TOKENS_FIELD_NUMBER: _ClassVar[int] + uuid: str + userName: str + tokens: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, uuid: _Optional[str] = ..., userName: _Optional[str] = ..., tokens: _Optional[_Iterable[str]] = ...) -> None: ... + +class ExecuteStatementRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class ExecuteStatementV2Request(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId", "params"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + PARAMS_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + params: _containers.RepeatedCompositeFieldContainer[ParameterValue] + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ..., params: _Optional[_Iterable[_Union[ParameterValue, _Mapping]]] = ...) -> None: ... + +class ExecuteStatementResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetNextResultRowRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class GetNextResultRowResponse(_message.Message): + __slots__ = ["resultRow"] + RESULTROW_FIELD_NUMBER: _ClassVar[int] + resultRow: bytes + def __init__(self, resultRow: _Optional[bytes] = ...) -> None: ... + +class GetNextResultBatchRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class GetNextResultBatchResponse(_message.Message): + __slots__ = ["resultBatch"] + RESULTBATCH_FIELD_NUMBER: _ClassVar[int] + resultBatch: bytes + def __init__(self, resultBatch: _Optional[bytes] = ...) -> None: ... + +class GetResultMetadataRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class GetResultMetadataResponse(_message.Message): + __slots__ = ["resultMetaData"] + RESULTMETADATA_FIELD_NUMBER: _ClassVar[int] + resultMetaData: bytes + def __init__(self, resultMetaData: _Optional[bytes] = ...) -> None: ... + +class AuthenticateRequest(_message.Message): + __slots__ = ["user", "password"] + USER_FIELD_NUMBER: _ClassVar[int] + PASSWORD_FIELD_NUMBER: _ClassVar[int] + user: str + password: str + def __init__(self, user: _Optional[str] = ..., password: _Optional[str] = ...) -> None: ... + +class AuthenticateResponse(_message.Message): + __slots__ = ["sessionId"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + sessionId: str + def __init__(self, sessionId: _Optional[str] = ...) -> None: ... + +class GetTablesRequest(_message.Message): + __slots__ = ["sessionId", "schema"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + sessionId: str + schema: str + def __init__(self, sessionId: _Optional[str] = ..., schema: _Optional[str] = ...) -> None: ... + +class GetTablesV2Request(_message.Message): + __slots__ = ["sessionId", "schema", "catalog"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + CATALOG_FIELD_NUMBER: _ClassVar[int] + sessionId: str + schema: str + catalog: str + def __init__(self, sessionId: _Optional[str] = ..., schema: _Optional[str] = ..., catalog: _Optional[str] = ...) -> None: ... + +class GetTablesResponse(_message.Message): + __slots__ = ["tables"] + TABLES_FIELD_NUMBER: _ClassVar[int] + tables: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, tables: _Optional[_Iterable[str]] = ...) -> None: ... + +class GetSchemaNamesRequest(_message.Message): + __slots__ = ["sessionId"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + sessionId: str + def __init__(self, sessionId: _Optional[str] = ...) -> None: ... + +class GetSchemaNamesV2Request(_message.Message): + __slots__ = ["sessionId", "catalog"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + CATALOG_FIELD_NUMBER: _ClassVar[int] + sessionId: str + catalog: str + def __init__(self, sessionId: _Optional[str] = ..., catalog: _Optional[str] = ...) -> None: ... + +class GetSchemaNamesResponse(_message.Message): + __slots__ = ["schemas"] + SCHEMAS_FIELD_NUMBER: _ClassVar[int] + schemas: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, schemas: _Optional[_Iterable[str]] = ...) -> None: ... + +class GetColumnsRequest(_message.Message): + __slots__ = ["sessionId", "schema", "table"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + TABLE_FIELD_NUMBER: _ClassVar[int] + sessionId: str + schema: str + table: str + def __init__(self, sessionId: _Optional[str] = ..., schema: _Optional[str] = ..., table: _Optional[str] = ...) -> None: ... + +class GetColumnsV2Request(_message.Message): + __slots__ = ["sessionId", "schema", "table", "catalog"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + TABLE_FIELD_NUMBER: _ClassVar[int] + CATALOG_FIELD_NUMBER: _ClassVar[int] + sessionId: str + schema: str + table: str + catalog: str + def __init__(self, sessionId: _Optional[str] = ..., schema: _Optional[str] = ..., table: _Optional[str] = ..., catalog: _Optional[str] = ...) -> None: ... + +class GetColumnsResponse(_message.Message): + __slots__ = ["fieldInfo"] + FIELDINFO_FIELD_NUMBER: _ClassVar[int] + fieldInfo: _containers.RepeatedCompositeFieldContainer[GFieldInfo] + def __init__(self, fieldInfo: _Optional[_Iterable[_Union[GFieldInfo, _Mapping]]] = ...) -> None: ... + +class StatusRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class StatusResponse(_message.Message): + __slots__ = ["status", "rowCount"] + STATUS_FIELD_NUMBER: _ClassVar[int] + ROWCOUNT_FIELD_NUMBER: _ClassVar[int] + status: bool + rowCount: int + def __init__(self, status: bool = ..., rowCount: _Optional[int] = ...) -> None: ... + +class AddCatalogsRequest(_message.Message): + __slots__ = ["sessionId", "json"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + JSON_FIELD_NUMBER: _ClassVar[int] + sessionId: str + json: str + def __init__(self, sessionId: _Optional[str] = ..., json: _Optional[str] = ...) -> None: ... + +class UpdateUsersRequest(_message.Message): + __slots__ = ["users"] + USERS_FIELD_NUMBER: _ClassVar[int] + users: bytes + def __init__(self, users: _Optional[bytes] = ...) -> None: ... + +class UpdateUsersResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class SetPropsRequest(_message.Message): + __slots__ = ["sessionId", "props"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + PROPS_FIELD_NUMBER: _ClassVar[int] + sessionId: str + props: str + def __init__(self, sessionId: _Optional[str] = ..., props: _Optional[str] = ...) -> None: ... + +class SetPropsResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetAddCatalogsRequest(_message.Message): + __slots__ = ["sessionId"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + sessionId: str + def __init__(self, sessionId: _Optional[str] = ...) -> None: ... + +class AddCatalogsResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetCatalogesRequest(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetCatalogesResponse(_message.Message): + __slots__ = ["catalogResponses"] + CATALOGRESPONSES_FIELD_NUMBER: _ClassVar[int] + catalogResponses: _containers.RepeatedCompositeFieldContainer[CatalogResponse] + def __init__(self, catalogResponses: _Optional[_Iterable[_Union[CatalogResponse, _Mapping]]] = ...) -> None: ... + +class RefreshCatalogsRequest(_message.Message): + __slots__ = ["sessionId"] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + sessionId: str + def __init__(self, sessionId: _Optional[str] = ...) -> None: ... + +class RefreshCatalogsResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class RemoteChunkRequest(_message.Message): + __slots__ = ["originalQueryId", "remoteQueryId", "sQueryHash"] + ORIGINALQUERYID_FIELD_NUMBER: _ClassVar[int] + REMOTEQUERYID_FIELD_NUMBER: _ClassVar[int] + SQUERYHASH_FIELD_NUMBER: _ClassVar[int] + originalQueryId: str + remoteQueryId: str + sQueryHash: str + def __init__(self, originalQueryId: _Optional[str] = ..., remoteQueryId: _Optional[str] = ..., sQueryHash: _Optional[str] = ...) -> None: ... + +class RemoteChunkResponse(_message.Message): + __slots__ = ["error", "chunk"] + ERROR_FIELD_NUMBER: _ClassVar[int] + CHUNK_FIELD_NUMBER: _ClassVar[int] + error: str + chunk: bytes + def __init__(self, error: _Optional[str] = ..., chunk: _Optional[bytes] = ...) -> None: ... + +class ClearOrCancelQueryRequest(_message.Message): + __slots__ = ["engineIP", "sessionId", "queryId"] + ENGINEIP_FIELD_NUMBER: _ClassVar[int] + SESSIONID_FIELD_NUMBER: _ClassVar[int] + QUERYID_FIELD_NUMBER: _ClassVar[int] + engineIP: str + sessionId: str + queryId: str + def __init__(self, engineIP: _Optional[str] = ..., sessionId: _Optional[str] = ..., queryId: _Optional[str] = ...) -> None: ... + +class ClearOrCancelQueryResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... diff --git a/e6xdb/server/e6x_engine_pb2_grpc.py b/e6xdb/server/e6x_engine_pb2_grpc.py new file mode 100644 index 0000000..8ba5a1a --- /dev/null +++ b/e6xdb/server/e6x_engine_pb2_grpc.py @@ -0,0 +1,991 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +import e6xdb.server.e6x_engine_pb2 as e6x__engine__pb2 + + +class QueryEngineServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.clear = channel.unary_unary( + '/QueryEngineService/clear', + request_serializer=e6x__engine__pb2.ClearRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.ClearResponse.FromString, + ) + self.cancelQuery = channel.unary_unary( + '/QueryEngineService/cancelQuery', + request_serializer=e6x__engine__pb2.CancelQueryRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.CancelQueryResponse.FromString, + ) + self.clearOrCancelQuery = channel.unary_unary( + '/QueryEngineService/clearOrCancelQuery', + request_serializer=e6x__engine__pb2.ClearOrCancelQueryRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.ClearOrCancelQueryResponse.FromString, + ) + self.explain = channel.unary_unary( + '/QueryEngineService/explain', + request_serializer=e6x__engine__pb2.ExplainRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.ExplainResponse.FromString, + ) + self.dryRun = channel.unary_unary( + '/QueryEngineService/dryRun', + request_serializer=e6x__engine__pb2.DryRunRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.DryRunResponse.FromString, + ) + self.dryRunV2 = channel.unary_unary( + '/QueryEngineService/dryRunV2', + request_serializer=e6x__engine__pb2.DryRunRequestV2.SerializeToString, + response_deserializer=e6x__engine__pb2.DryRunResponse.FromString, + ) + self.explainAnalyze = channel.unary_unary( + '/QueryEngineService/explainAnalyze', + request_serializer=e6x__engine__pb2.ExplainAnalyzeRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.ExplainAnalyzeResponse.FromString, + ) + self.prepareStatement = channel.unary_unary( + '/QueryEngineService/prepareStatement', + request_serializer=e6x__engine__pb2.PrepareStatementRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.PrepareStatementResponse.FromString, + ) + self.prepareStatementV2 = channel.unary_unary( + '/QueryEngineService/prepareStatementV2', + request_serializer=e6x__engine__pb2.PrepareStatementV2Request.SerializeToString, + response_deserializer=e6x__engine__pb2.PrepareStatementResponse.FromString, + ) + self.executeStatement = channel.unary_unary( + '/QueryEngineService/executeStatement', + request_serializer=e6x__engine__pb2.ExecuteStatementRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.ExecuteStatementResponse.FromString, + ) + self.executeStatementV2 = channel.unary_unary( + '/QueryEngineService/executeStatementV2', + request_serializer=e6x__engine__pb2.ExecuteStatementV2Request.SerializeToString, + response_deserializer=e6x__engine__pb2.ExecuteStatementResponse.FromString, + ) + self.getNextResultRow = channel.unary_unary( + '/QueryEngineService/getNextResultRow', + request_serializer=e6x__engine__pb2.GetNextResultRowRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetNextResultRowResponse.FromString, + ) + self.getNextResultBatch = channel.unary_unary( + '/QueryEngineService/getNextResultBatch', + request_serializer=e6x__engine__pb2.GetNextResultBatchRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetNextResultBatchResponse.FromString, + ) + self.getResultMetadata = channel.unary_unary( + '/QueryEngineService/getResultMetadata', + request_serializer=e6x__engine__pb2.GetResultMetadataRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetResultMetadataResponse.FromString, + ) + self.authenticate = channel.unary_unary( + '/QueryEngineService/authenticate', + request_serializer=e6x__engine__pb2.AuthenticateRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.AuthenticateResponse.FromString, + ) + self.getTables = channel.unary_unary( + '/QueryEngineService/getTables', + request_serializer=e6x__engine__pb2.GetTablesRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetTablesResponse.FromString, + ) + self.getTablesV2 = channel.unary_unary( + '/QueryEngineService/getTablesV2', + request_serializer=e6x__engine__pb2.GetTablesV2Request.SerializeToString, + response_deserializer=e6x__engine__pb2.GetTablesResponse.FromString, + ) + self.getSchemaNames = channel.unary_unary( + '/QueryEngineService/getSchemaNames', + request_serializer=e6x__engine__pb2.GetSchemaNamesRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetSchemaNamesResponse.FromString, + ) + self.getSchemaNamesV2 = channel.unary_unary( + '/QueryEngineService/getSchemaNamesV2', + request_serializer=e6x__engine__pb2.GetSchemaNamesV2Request.SerializeToString, + response_deserializer=e6x__engine__pb2.GetSchemaNamesResponse.FromString, + ) + self.getColumns = channel.unary_unary( + '/QueryEngineService/getColumns', + request_serializer=e6x__engine__pb2.GetColumnsRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetColumnsResponse.FromString, + ) + self.getColumnsV2 = channel.unary_unary( + '/QueryEngineService/getColumnsV2', + request_serializer=e6x__engine__pb2.GetColumnsV2Request.SerializeToString, + response_deserializer=e6x__engine__pb2.GetColumnsResponse.FromString, + ) + self.updateUsers = channel.unary_unary( + '/QueryEngineService/updateUsers', + request_serializer=e6x__engine__pb2.UpdateUsersRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.UpdateUsersResponse.FromString, + ) + self.setProps = channel.unary_unary( + '/QueryEngineService/setProps', + request_serializer=e6x__engine__pb2.SetPropsRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.SetPropsResponse.FromString, + ) + self.status = channel.unary_unary( + '/QueryEngineService/status', + request_serializer=e6x__engine__pb2.StatusRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.StatusResponse.FromString, + ) + self.addCatalogs = channel.unary_unary( + '/QueryEngineService/addCatalogs', + request_serializer=e6x__engine__pb2.AddCatalogsRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.AddCatalogsResponse.FromString, + ) + self.getAddCatalogsResponse = channel.unary_unary( + '/QueryEngineService/getAddCatalogsResponse', + request_serializer=e6x__engine__pb2.GetAddCatalogsRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetAddCatalogsResponse.FromString, + ) + self.getCataloges = channel.unary_unary( + '/QueryEngineService/getCataloges', + request_serializer=e6x__engine__pb2.GetCatalogesRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.GetCatalogesResponse.FromString, + ) + self.getNextRemoteCachedChunk = channel.unary_unary( + '/QueryEngineService/getNextRemoteCachedChunk', + request_serializer=e6x__engine__pb2.RemoteChunkRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.RemoteChunkResponse.FromString, + ) + self.refreshCatalogs = channel.unary_unary( + '/QueryEngineService/refreshCatalogs', + request_serializer=e6x__engine__pb2.RefreshCatalogsRequest.SerializeToString, + response_deserializer=e6x__engine__pb2.RefreshCatalogsResponse.FromString, + ) + + +class QueryEngineServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def clear(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def cancelQuery(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def clearOrCancelQuery(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def explain(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def dryRun(self, request, context): + """Executor, Engine + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def dryRunV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def explainAnalyze(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def prepareStatement(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def prepareStatementV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def executeStatement(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def executeStatementV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getNextResultRow(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getNextResultBatch(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getResultMetadata(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def authenticate(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getTables(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getTablesV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getSchemaNames(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getSchemaNamesV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getColumns(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getColumnsV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def updateUsers(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def setProps(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def status(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def addCatalogs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getAddCatalogsResponse(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getCataloges(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def getNextRemoteCachedChunk(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def refreshCatalogs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_QueryEngineServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'clear': grpc.unary_unary_rpc_method_handler( + servicer.clear, + request_deserializer=e6x__engine__pb2.ClearRequest.FromString, + response_serializer=e6x__engine__pb2.ClearResponse.SerializeToString, + ), + 'cancelQuery': grpc.unary_unary_rpc_method_handler( + servicer.cancelQuery, + request_deserializer=e6x__engine__pb2.CancelQueryRequest.FromString, + response_serializer=e6x__engine__pb2.CancelQueryResponse.SerializeToString, + ), + 'clearOrCancelQuery': grpc.unary_unary_rpc_method_handler( + servicer.clearOrCancelQuery, + request_deserializer=e6x__engine__pb2.ClearOrCancelQueryRequest.FromString, + response_serializer=e6x__engine__pb2.ClearOrCancelQueryResponse.SerializeToString, + ), + 'explain': grpc.unary_unary_rpc_method_handler( + servicer.explain, + request_deserializer=e6x__engine__pb2.ExplainRequest.FromString, + response_serializer=e6x__engine__pb2.ExplainResponse.SerializeToString, + ), + 'dryRun': grpc.unary_unary_rpc_method_handler( + servicer.dryRun, + request_deserializer=e6x__engine__pb2.DryRunRequest.FromString, + response_serializer=e6x__engine__pb2.DryRunResponse.SerializeToString, + ), + 'dryRunV2': grpc.unary_unary_rpc_method_handler( + servicer.dryRunV2, + request_deserializer=e6x__engine__pb2.DryRunRequestV2.FromString, + response_serializer=e6x__engine__pb2.DryRunResponse.SerializeToString, + ), + 'explainAnalyze': grpc.unary_unary_rpc_method_handler( + servicer.explainAnalyze, + request_deserializer=e6x__engine__pb2.ExplainAnalyzeRequest.FromString, + response_serializer=e6x__engine__pb2.ExplainAnalyzeResponse.SerializeToString, + ), + 'prepareStatement': grpc.unary_unary_rpc_method_handler( + servicer.prepareStatement, + request_deserializer=e6x__engine__pb2.PrepareStatementRequest.FromString, + response_serializer=e6x__engine__pb2.PrepareStatementResponse.SerializeToString, + ), + 'prepareStatementV2': grpc.unary_unary_rpc_method_handler( + servicer.prepareStatementV2, + request_deserializer=e6x__engine__pb2.PrepareStatementV2Request.FromString, + response_serializer=e6x__engine__pb2.PrepareStatementResponse.SerializeToString, + ), + 'executeStatement': grpc.unary_unary_rpc_method_handler( + servicer.executeStatement, + request_deserializer=e6x__engine__pb2.ExecuteStatementRequest.FromString, + response_serializer=e6x__engine__pb2.ExecuteStatementResponse.SerializeToString, + ), + 'executeStatementV2': grpc.unary_unary_rpc_method_handler( + servicer.executeStatementV2, + request_deserializer=e6x__engine__pb2.ExecuteStatementV2Request.FromString, + response_serializer=e6x__engine__pb2.ExecuteStatementResponse.SerializeToString, + ), + 'getNextResultRow': grpc.unary_unary_rpc_method_handler( + servicer.getNextResultRow, + request_deserializer=e6x__engine__pb2.GetNextResultRowRequest.FromString, + response_serializer=e6x__engine__pb2.GetNextResultRowResponse.SerializeToString, + ), + 'getNextResultBatch': grpc.unary_unary_rpc_method_handler( + servicer.getNextResultBatch, + request_deserializer=e6x__engine__pb2.GetNextResultBatchRequest.FromString, + response_serializer=e6x__engine__pb2.GetNextResultBatchResponse.SerializeToString, + ), + 'getResultMetadata': grpc.unary_unary_rpc_method_handler( + servicer.getResultMetadata, + request_deserializer=e6x__engine__pb2.GetResultMetadataRequest.FromString, + response_serializer=e6x__engine__pb2.GetResultMetadataResponse.SerializeToString, + ), + 'authenticate': grpc.unary_unary_rpc_method_handler( + servicer.authenticate, + request_deserializer=e6x__engine__pb2.AuthenticateRequest.FromString, + response_serializer=e6x__engine__pb2.AuthenticateResponse.SerializeToString, + ), + 'getTables': grpc.unary_unary_rpc_method_handler( + servicer.getTables, + request_deserializer=e6x__engine__pb2.GetTablesRequest.FromString, + response_serializer=e6x__engine__pb2.GetTablesResponse.SerializeToString, + ), + 'getTablesV2': grpc.unary_unary_rpc_method_handler( + servicer.getTablesV2, + request_deserializer=e6x__engine__pb2.GetTablesV2Request.FromString, + response_serializer=e6x__engine__pb2.GetTablesResponse.SerializeToString, + ), + 'getSchemaNames': grpc.unary_unary_rpc_method_handler( + servicer.getSchemaNames, + request_deserializer=e6x__engine__pb2.GetSchemaNamesRequest.FromString, + response_serializer=e6x__engine__pb2.GetSchemaNamesResponse.SerializeToString, + ), + 'getSchemaNamesV2': grpc.unary_unary_rpc_method_handler( + servicer.getSchemaNamesV2, + request_deserializer=e6x__engine__pb2.GetSchemaNamesV2Request.FromString, + response_serializer=e6x__engine__pb2.GetSchemaNamesResponse.SerializeToString, + ), + 'getColumns': grpc.unary_unary_rpc_method_handler( + servicer.getColumns, + request_deserializer=e6x__engine__pb2.GetColumnsRequest.FromString, + response_serializer=e6x__engine__pb2.GetColumnsResponse.SerializeToString, + ), + 'getColumnsV2': grpc.unary_unary_rpc_method_handler( + servicer.getColumnsV2, + request_deserializer=e6x__engine__pb2.GetColumnsV2Request.FromString, + response_serializer=e6x__engine__pb2.GetColumnsResponse.SerializeToString, + ), + 'updateUsers': grpc.unary_unary_rpc_method_handler( + servicer.updateUsers, + request_deserializer=e6x__engine__pb2.UpdateUsersRequest.FromString, + response_serializer=e6x__engine__pb2.UpdateUsersResponse.SerializeToString, + ), + 'setProps': grpc.unary_unary_rpc_method_handler( + servicer.setProps, + request_deserializer=e6x__engine__pb2.SetPropsRequest.FromString, + response_serializer=e6x__engine__pb2.SetPropsResponse.SerializeToString, + ), + 'status': grpc.unary_unary_rpc_method_handler( + servicer.status, + request_deserializer=e6x__engine__pb2.StatusRequest.FromString, + response_serializer=e6x__engine__pb2.StatusResponse.SerializeToString, + ), + 'addCatalogs': grpc.unary_unary_rpc_method_handler( + servicer.addCatalogs, + request_deserializer=e6x__engine__pb2.AddCatalogsRequest.FromString, + response_serializer=e6x__engine__pb2.AddCatalogsResponse.SerializeToString, + ), + 'getAddCatalogsResponse': grpc.unary_unary_rpc_method_handler( + servicer.getAddCatalogsResponse, + request_deserializer=e6x__engine__pb2.GetAddCatalogsRequest.FromString, + response_serializer=e6x__engine__pb2.GetAddCatalogsResponse.SerializeToString, + ), + 'getCataloges': grpc.unary_unary_rpc_method_handler( + servicer.getCataloges, + request_deserializer=e6x__engine__pb2.GetCatalogesRequest.FromString, + response_serializer=e6x__engine__pb2.GetCatalogesResponse.SerializeToString, + ), + 'getNextRemoteCachedChunk': grpc.unary_unary_rpc_method_handler( + servicer.getNextRemoteCachedChunk, + request_deserializer=e6x__engine__pb2.RemoteChunkRequest.FromString, + response_serializer=e6x__engine__pb2.RemoteChunkResponse.SerializeToString, + ), + 'refreshCatalogs': grpc.unary_unary_rpc_method_handler( + servicer.refreshCatalogs, + request_deserializer=e6x__engine__pb2.RefreshCatalogsRequest.FromString, + response_serializer=e6x__engine__pb2.RefreshCatalogsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'QueryEngineService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class QueryEngineService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def clear(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/clear', + e6x__engine__pb2.ClearRequest.SerializeToString, + e6x__engine__pb2.ClearResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def cancelQuery(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/cancelQuery', + e6x__engine__pb2.CancelQueryRequest.SerializeToString, + e6x__engine__pb2.CancelQueryResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def clearOrCancelQuery(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/clearOrCancelQuery', + e6x__engine__pb2.ClearOrCancelQueryRequest.SerializeToString, + e6x__engine__pb2.ClearOrCancelQueryResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def explain(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/explain', + e6x__engine__pb2.ExplainRequest.SerializeToString, + e6x__engine__pb2.ExplainResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def dryRun(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/dryRun', + e6x__engine__pb2.DryRunRequest.SerializeToString, + e6x__engine__pb2.DryRunResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def dryRunV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/dryRunV2', + e6x__engine__pb2.DryRunRequestV2.SerializeToString, + e6x__engine__pb2.DryRunResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def explainAnalyze(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/explainAnalyze', + e6x__engine__pb2.ExplainAnalyzeRequest.SerializeToString, + e6x__engine__pb2.ExplainAnalyzeResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def prepareStatement(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/prepareStatement', + e6x__engine__pb2.PrepareStatementRequest.SerializeToString, + e6x__engine__pb2.PrepareStatementResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def prepareStatementV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/prepareStatementV2', + e6x__engine__pb2.PrepareStatementV2Request.SerializeToString, + e6x__engine__pb2.PrepareStatementResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def executeStatement(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/executeStatement', + e6x__engine__pb2.ExecuteStatementRequest.SerializeToString, + e6x__engine__pb2.ExecuteStatementResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def executeStatementV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/executeStatementV2', + e6x__engine__pb2.ExecuteStatementV2Request.SerializeToString, + e6x__engine__pb2.ExecuteStatementResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getNextResultRow(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getNextResultRow', + e6x__engine__pb2.GetNextResultRowRequest.SerializeToString, + e6x__engine__pb2.GetNextResultRowResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getNextResultBatch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getNextResultBatch', + e6x__engine__pb2.GetNextResultBatchRequest.SerializeToString, + e6x__engine__pb2.GetNextResultBatchResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getResultMetadata(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getResultMetadata', + e6x__engine__pb2.GetResultMetadataRequest.SerializeToString, + e6x__engine__pb2.GetResultMetadataResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def authenticate(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/authenticate', + e6x__engine__pb2.AuthenticateRequest.SerializeToString, + e6x__engine__pb2.AuthenticateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getTables(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getTables', + e6x__engine__pb2.GetTablesRequest.SerializeToString, + e6x__engine__pb2.GetTablesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getTablesV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getTablesV2', + e6x__engine__pb2.GetTablesV2Request.SerializeToString, + e6x__engine__pb2.GetTablesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getSchemaNames(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getSchemaNames', + e6x__engine__pb2.GetSchemaNamesRequest.SerializeToString, + e6x__engine__pb2.GetSchemaNamesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getSchemaNamesV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getSchemaNamesV2', + e6x__engine__pb2.GetSchemaNamesV2Request.SerializeToString, + e6x__engine__pb2.GetSchemaNamesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getColumns(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getColumns', + e6x__engine__pb2.GetColumnsRequest.SerializeToString, + e6x__engine__pb2.GetColumnsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getColumnsV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getColumnsV2', + e6x__engine__pb2.GetColumnsV2Request.SerializeToString, + e6x__engine__pb2.GetColumnsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def updateUsers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/updateUsers', + e6x__engine__pb2.UpdateUsersRequest.SerializeToString, + e6x__engine__pb2.UpdateUsersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def setProps(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/setProps', + e6x__engine__pb2.SetPropsRequest.SerializeToString, + e6x__engine__pb2.SetPropsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def status(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/status', + e6x__engine__pb2.StatusRequest.SerializeToString, + e6x__engine__pb2.StatusResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def addCatalogs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/addCatalogs', + e6x__engine__pb2.AddCatalogsRequest.SerializeToString, + e6x__engine__pb2.AddCatalogsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getAddCatalogsResponse(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getAddCatalogsResponse', + e6x__engine__pb2.GetAddCatalogsRequest.SerializeToString, + e6x__engine__pb2.GetAddCatalogsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getCataloges(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getCataloges', + e6x__engine__pb2.GetCatalogesRequest.SerializeToString, + e6x__engine__pb2.GetCatalogesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def getNextRemoteCachedChunk(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/getNextRemoteCachedChunk', + e6x__engine__pb2.RemoteChunkRequest.SerializeToString, + e6x__engine__pb2.RemoteChunkResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def refreshCatalogs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/QueryEngineService/refreshCatalogs', + e6x__engine__pb2.RefreshCatalogsRequest.SerializeToString, + e6x__engine__pb2.RefreshCatalogsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/requirements.txt b/requirements.txt index 5140797..c45d424 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,27 +1,28 @@ -bleach==5.0.0 -certifi==2022.5.18.1 -charset-normalizer==2.0.12 +bleach==6.0.0 +certifi==2023.7.22 +charset-normalizer==3.2.0 commonmark==0.9.1 -docutils==0.18.1 -future==0.18.2 -greenlet==1.1.2 -idna==3.3 -importlib-metadata==4.11.4 -keyring==23.5.1 -pkginfo==1.8.2 -pycryptodome==3.14.1 -Pygments==2.12.0 +docutils==0.20.1 +future==0.18.3 +greenlet==2.0.2 +grpcio==1.56.2 +grpcio-tools==1.56.2 +idna==3.4 +importlib-metadata==6.8.0 +keyring==24.2.0 +pkginfo==1.9.6 +pycryptodome==3.18.0 +Pygments==2.16.1 python-dateutil==2.8.2 pytz -readme-renderer==35.0 -requests==2.27.1 -requests-toolbelt==0.9.1 +readme-renderer==40.0 +requests==2.31.0 +requests-toolbelt==1.0.0 rfc3986==2.0.0 -rich==12.4.4 +rich==13.5.2 six==1.16.0 -SQLAlchemy==1.4.36 thrift==0.16.0 -twine==4.0.0 -urllib3==1.26.9 +twine==4.0.2 +urllib3==2.0.4 webencodings==0.5.1 -zipp==3.8.0 +zipp==3.16.2 \ No newline at end of file diff --git a/tests_grpc.py b/tests_grpc.py new file mode 100644 index 0000000..a59389c --- /dev/null +++ b/tests_grpc.py @@ -0,0 +1,158 @@ +import csv +import os +import time +from unittest import TestCase +import e6xdb.e6xgrpc as edb + +import logging + +logging.getLogger(__name__) +logging.basicConfig(level=logging.DEBUG) + + +class TestE6X(TestCase): + def setUp(self) -> None: + self._host = "127.0.0.1" + self._database = "tpcds_ci" + self.e6x_connection = None + logging.debug('Trying to connect to engine host {}, database {}.'.format(self._host, self._database)) + self.e6x_connection = edb.connect( + host=self._host, + port=9001, + scheme='e6xdb', + username='vishal@e6x.io', + database=self._database, + auth=None, + configuration=None, + kerberos_service_name=None, + password='75cei^%$TREdgfhU&T^RTYDrchfgvjy65dhcgf', + check_hostname=None, + ssl_cert=None, + thrift_transport=None + ) + logging.debug('Successfully to connect to engine.') + + def test_connection(self): + self.assertIsNotNone(self.e6x_connection, 'Unable to connect.') + + def disconnect(self): + self.e6x_connection.close() + self.assertFalse(self.e6x_connection.check_connection()) + + def test_query_1(self): + sql = 'select 1' + logging.debug('Executing query: {}'.format(sql)) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + logging.debug('Query Id {}'.format(query_id)) + self.assertIsNotNone(query_id) + records = cursor.fetchall() + self.assertIn(1, records[0]) + cursor.clear() + self.e6x_connection.close() + + def test_query_2(self): + sql = "select timestamp_add('year',2,current_date())" + logging.debug('Executing query: {}'.format(sql)) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + logging.debug('Query Id {}'.format(query_id)) + self.assertIsNotNone(query_id) + records = cursor.fetchall() + cursor.clear() + self.assertEqual(1, len(records)) + self.e6x_connection.close() + + def test_query_3_fetch_one(self): + sql = "select * from date_dim limit 3" + logging.debug('Executing query: {}'.format(sql)) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + logging.debug('Query Id {}'.format(query_id)) + self.assertIsNotNone(query_id) + records = cursor.fetchone() + cursor.clear() + self.assertEqual(1, len(records)) + self.e6x_connection.close() + + def test_query_4_fetch_many(self): + sql = "select * from date_dim limit 3" + logging.debug('Executing query: {}'.format(sql)) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + logging.debug('Query Id {}'.format(query_id)) + self.assertIsNotNone(query_id) + records = cursor.fetchmany(1) + cursor.clear() + self.assertEqual(1, len(records)) + self.e6x_connection.close() + + def test_query_5_dry_run(self): + sql = "select * from date_dim limit 3" + logging.debug('Executing query: {}'.format(sql)) + response = self.e6x_connection.dry_run(sql) + self.assertIsNotNone(response) + self.e6x_connection.close() + + def test_query_5_caches(self): + sql = "select * from date_dim limit 3" + logging.debug('Executing query: {}'.format(sql)) + self.e6x_connection.set_or_update_caches(True) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + logging.debug('Query Id {}'.format(query_id)) + self.assertIsNotNone(query_id) + records = cursor.fetchall() + self.e6x_connection.set_or_update_caches(False) + now = time.time() + query_id = cursor.execute(sql) + logging.debug('Query Id {}'.format(query_id)) + records = cursor.fetchall() + print('After cache, execution time', time.time() - now) + cursor.clear() + self.e6x_connection.close() + + def test_query_6_explain_analyse(self): + sql = "select * from date_dim limit 3" + logging.debug('Executing query: {}'.format(sql)) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + cursor.explain_analyse() + self.e6x_connection.close() + + def test_query_7_explain(self): + sql = "select * from date_dim limit 3" + logging.debug('Executing query: {}'.format(sql)) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + cursor.explain() + self.e6x_connection.close() + + def tearDown(self) -> None: + self.disconnect() + + def test_get_query_list_from_csv_file(self): + query_path = os.getenv("QUERY_PATH") or './query_file.csv' + query_column_name = os.getenv("QUERY_CSV_COLUMN_NAME") or 'QUERY' + logging.debug('Query path found: {}'.format(query_path)) + if query_path: + if not query_path.endswith('.csv'): + raise Exception('Invalid QUERY_PATH: Only CSV file is supported.') + local_file_path = query_path + data = list() + with open(local_file_path, 'r') as fh: + reader = csv.DictReader(fh) + for row in reader: + data.append({ + 'query': row.get(query_column_name), + 'query_id': row.get('QUERY_ID') or None, + }) + for row in data: + sql = row.get("query") + logging.debug('Executing query: {}'.format(sql)) + cursor = self.e6x_connection.cursor() + query_id = cursor.execute(sql) + logging.debug('Query Id {}'.format(query_id)) + self.assertIsNotNone(query_id) + records = cursor.fetchall() + self.assertGreater(len(records[0]), 0) From 48cc2faa0fab5e36ecee8f97ecb04b9c579a7266 Mon Sep 17 00:00:00 2001 From: Vishal Anand <101251245+vishale6x@users.noreply.github.com> Date: Tue, 8 Aug 2023 23:14:49 +0530 Subject: [PATCH 2/4] GRPC connection added. --- e6data_python_connector/__init__.py | 3 ++ {e6xdb => e6data_python_connector}/e6xgrpc.py | 45 +++---------------- .../server/QueryEngineService-remote | 6 +-- .../server/QueryEngineService.py | 0 .../server/__init__.py | 0 .../server/constants.py | 0 .../server/e6x_engine_pb2.py | 0 .../server/e6x_engine_pb2.pyi | 0 .../server/e6x_engine_pb2_grpc.py | 2 +- .../server/ttypes.py | 0 e6xdb/e6x.py | 2 +- tests_grpc.py | 39 +++++++--------- 12 files changed, 29 insertions(+), 68 deletions(-) create mode 100644 e6data_python_connector/__init__.py rename {e6xdb => e6data_python_connector}/e6xgrpc.py (93%) rename {e6xdb => e6data_python_connector}/server/QueryEngineService-remote (97%) rename {e6xdb => e6data_python_connector}/server/QueryEngineService.py (100%) rename {e6xdb => e6data_python_connector}/server/__init__.py (100%) rename {e6xdb => e6data_python_connector}/server/constants.py (100%) rename {e6xdb => e6data_python_connector}/server/e6x_engine_pb2.py (100%) rename {e6xdb => e6data_python_connector}/server/e6x_engine_pb2.pyi (100%) rename {e6xdb => e6data_python_connector}/server/e6x_engine_pb2_grpc.py (99%) rename {e6xdb => e6data_python_connector}/server/ttypes.py (100%) diff --git a/e6data_python_connector/__init__.py b/e6data_python_connector/__init__.py new file mode 100644 index 0000000..380fcae --- /dev/null +++ b/e6data_python_connector/__init__.py @@ -0,0 +1,3 @@ +from e6data_python_connector.e6xgrpc import Connection, Cursor + +__all__ = ['Connection', 'Cursor'] diff --git a/e6xdb/e6xgrpc.py b/e6data_python_connector/e6xgrpc.py similarity index 93% rename from e6xdb/e6xgrpc.py rename to e6data_python_connector/e6xgrpc.py index d3a5447..e5871e0 100644 --- a/e6xdb/e6xgrpc.py +++ b/e6data_python_connector/e6xgrpc.py @@ -20,7 +20,7 @@ from e6xdb.common import DBAPITypeObject, ParamEscaper, DBAPICursor from e6xdb.constants import * from e6xdb.datainputstream import DataInputStream, get_query_columns_info, read_rows_from_batch, read_values_from_array -from e6xdb.server import e6x_engine_pb2_grpc, e6x_engine_pb2 +from e6data_python_connector.server import e6x_engine_pb2_grpc, e6x_engine_pb2 from e6xdb.typeId import * apilevel = '2.0' @@ -225,7 +225,7 @@ def commit(self): """We do not support transactions, so this does nothing.""" pass - def cursor(self, db_name=None, catalog_name=None): + def cursor(self, catalog_name: str, db_name=None): """Return a new :py:class:`Cursor` object using the connection.""" return Cursor(self, database=db_name, catalog_name=catalog_name) @@ -245,9 +245,9 @@ class Cursor(DBAPICursor): """ rows_count = 0 - def __init__(self, connection: Connection, arraysize=1000, database=None, catalog_name=None): + def __init__(self, connection: Connection, array_size=1000, database=None, catalog_name=None): super(Cursor, self).__init__() - self._arraysize = arraysize + self._array_size = array_size self.connection = connection self._data = None self._query_columns_description = None @@ -334,21 +334,14 @@ def get_columns(self, table): return self.connection.get_columns(database=schema, table=table) def clear(self): - """Clears the tmp data""" - # self.connection.clear( - # query_id=self._query_id, - # engine_ip=self._engine_ip - # ) clear_request = e6x_engine_pb2.ClearRequest( sessionId=self.connection.get_session_id, queryId=self._query_id, engineIP=self._engine_ip ) - response = self.connection.client.clear(clear_request) - print(response) + return self.connection.client.clear(clear_request) def cancel(self, query_id): - _logger.info("Cancelling query") self.connection.query_cancel(engine_ip=self._engine_ip, query_id=query_id) def status(self, query_id): @@ -567,31 +560,3 @@ class Error(Exception): for type_id in PRIMITIVE_TYPES: name = TypeId._VALUES_TO_NAMES[type_id] setattr(sys.modules[__name__], name, DBAPITypeObject([name])) - -if __name__ == '__main__': - query = 'select * from catalog_sales' - conn = Connection( - host='localhost', - port=4000, - username='shubham@e6x.io', - password='w3aSShTYPGt12Z8QuCXcxuAggKB4INyEzDwg1WFj0THDgJRMuwryt5dt', - database='tpcds_1000' - ) - cursor = conn.cursor( - catalog_name='perfhive', - db_name='tpcds_1000' - ) - qid = cursor.execute(query) - print(qid, qid) - # print(cursor.cancel(qid)) - for i in cursor.fetchall_buffer(): - print(sys.getsizeof(i)) - print(cursor.cancel(qid)) - break - # print('Response size', sys.getsizeof(res)) - try: - cursor.clear() - except Exception as e: - print(e) - cursor.close() - conn.close() diff --git a/e6xdb/server/QueryEngineService-remote b/e6data_python_connector/server/QueryEngineService-remote similarity index 97% rename from e6xdb/server/QueryEngineService-remote rename to e6data_python_connector/server/QueryEngineService-remote index d3a1c05..fdf9233 100755 --- a/e6xdb/server/QueryEngineService-remote +++ b/e6data_python_connector/server/QueryEngineService-remote @@ -13,11 +13,11 @@ if sys.version_info[0] > 2: from urllib.parse import urlparse else: from urlparse import urlparse -from thrift.transport import TTransport, TSocket, TSSLSocket, THttpClient +from thrift.transport import TSocket, TSSLSocket, THttpClient from thrift.protocol.TBinaryProtocol import TBinaryProtocol -from e6xdb.server import QueryEngineService -from e6xdb.server.ttypes import * +from e6data_python_connector.server import QueryEngineService +from e6data_python_connector.server.ttypes import * if len(sys.argv) <= 1 or sys.argv[1] == '--help': print('') diff --git a/e6xdb/server/QueryEngineService.py b/e6data_python_connector/server/QueryEngineService.py similarity index 100% rename from e6xdb/server/QueryEngineService.py rename to e6data_python_connector/server/QueryEngineService.py diff --git a/e6xdb/server/__init__.py b/e6data_python_connector/server/__init__.py similarity index 100% rename from e6xdb/server/__init__.py rename to e6data_python_connector/server/__init__.py diff --git a/e6xdb/server/constants.py b/e6data_python_connector/server/constants.py similarity index 100% rename from e6xdb/server/constants.py rename to e6data_python_connector/server/constants.py diff --git a/e6xdb/server/e6x_engine_pb2.py b/e6data_python_connector/server/e6x_engine_pb2.py similarity index 100% rename from e6xdb/server/e6x_engine_pb2.py rename to e6data_python_connector/server/e6x_engine_pb2.py diff --git a/e6xdb/server/e6x_engine_pb2.pyi b/e6data_python_connector/server/e6x_engine_pb2.pyi similarity index 100% rename from e6xdb/server/e6x_engine_pb2.pyi rename to e6data_python_connector/server/e6x_engine_pb2.pyi diff --git a/e6xdb/server/e6x_engine_pb2_grpc.py b/e6data_python_connector/server/e6x_engine_pb2_grpc.py similarity index 99% rename from e6xdb/server/e6x_engine_pb2_grpc.py rename to e6data_python_connector/server/e6x_engine_pb2_grpc.py index 8ba5a1a..4b3fbf3 100644 --- a/e6xdb/server/e6x_engine_pb2_grpc.py +++ b/e6data_python_connector/server/e6x_engine_pb2_grpc.py @@ -2,7 +2,7 @@ """Client and server classes corresponding to protobuf-defined services.""" import grpc -import e6xdb.server.e6x_engine_pb2 as e6x__engine__pb2 +import e6data_python_connector.server.e6x_engine_pb2 as e6x__engine__pb2 class QueryEngineServiceStub(object): diff --git a/e6xdb/server/ttypes.py b/e6data_python_connector/server/ttypes.py similarity index 100% rename from e6xdb/server/ttypes.py rename to e6data_python_connector/server/ttypes.py diff --git a/e6xdb/e6x.py b/e6xdb/e6x.py index e6b30f7..b80656f 100644 --- a/e6xdb/e6x.py +++ b/e6xdb/e6x.py @@ -15,7 +15,7 @@ from io import BytesIO from ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED -from e6xdb.server import QueryEngineService +from e6data_python_connector.server import QueryEngineService from thrift.protocol import TBinaryProtocol, TMultiplexedProtocol from thrift.transport import TSocket from thrift.transport import TTransport diff --git a/tests_grpc.py b/tests_grpc.py index a59389c..73da983 100644 --- a/tests_grpc.py +++ b/tests_grpc.py @@ -2,7 +2,7 @@ import os import time from unittest import TestCase -import e6xdb.e6xgrpc as edb +from e6data_python_connector import Connection import logging @@ -13,22 +13,15 @@ class TestE6X(TestCase): def setUp(self) -> None: self._host = "127.0.0.1" - self._database = "tpcds_ci" - self.e6x_connection = None + self._database = "tpcds_1000" + self.catalog_name = 'perfhive' logging.debug('Trying to connect to engine host {}, database {}.'.format(self._host, self._database)) - self.e6x_connection = edb.connect( + self.e6x_connection = Connection( host=self._host, - port=9001, - scheme='e6xdb', - username='vishal@e6x.io', + port=4000, + username='shubham@e6x.io', database=self._database, - auth=None, - configuration=None, - kerberos_service_name=None, - password='75cei^%$TREdgfhU&T^RTYDrchfgvjy65dhcgf', - check_hostname=None, - ssl_cert=None, - thrift_transport=None + password='w3aSShTYPGt12Z8QuCXcxuAggKB4INyEzDwg1WFj0THDgJRMuwryt5dt', ) logging.debug('Successfully to connect to engine.') @@ -42,7 +35,7 @@ def disconnect(self): def test_query_1(self): sql = 'select 1' logging.debug('Executing query: {}'.format(sql)) - cursor = self.e6x_connection.cursor() + cursor = self.e6x_connection.cursor(catalog_name=self.catalog_name) query_id = cursor.execute(sql) logging.debug('Query Id {}'.format(query_id)) self.assertIsNotNone(query_id) @@ -54,7 +47,7 @@ def test_query_1(self): def test_query_2(self): sql = "select timestamp_add('year',2,current_date())" logging.debug('Executing query: {}'.format(sql)) - cursor = self.e6x_connection.cursor() + cursor = self.e6x_connection.cursor(catalog_name=self.catalog_name) query_id = cursor.execute(sql) logging.debug('Query Id {}'.format(query_id)) self.assertIsNotNone(query_id) @@ -66,7 +59,7 @@ def test_query_2(self): def test_query_3_fetch_one(self): sql = "select * from date_dim limit 3" logging.debug('Executing query: {}'.format(sql)) - cursor = self.e6x_connection.cursor() + cursor = self.e6x_connection.cursor(catalog_name=self.catalog_name) query_id = cursor.execute(sql) logging.debug('Query Id {}'.format(query_id)) self.assertIsNotNone(query_id) @@ -78,7 +71,7 @@ def test_query_3_fetch_one(self): def test_query_4_fetch_many(self): sql = "select * from date_dim limit 3" logging.debug('Executing query: {}'.format(sql)) - cursor = self.e6x_connection.cursor() + cursor = self.e6x_connection.cursor(catalog_name=self.catalog_name) query_id = cursor.execute(sql) logging.debug('Query Id {}'.format(query_id)) self.assertIsNotNone(query_id) @@ -97,13 +90,13 @@ def test_query_5_dry_run(self): def test_query_5_caches(self): sql = "select * from date_dim limit 3" logging.debug('Executing query: {}'.format(sql)) - self.e6x_connection.set_or_update_caches(True) - cursor = self.e6x_connection.cursor() + # self.e6x_connection.set_or_update_caches(True) + cursor = self.e6x_connection.cursor(catalog_name=self.catalog_name) query_id = cursor.execute(sql) logging.debug('Query Id {}'.format(query_id)) self.assertIsNotNone(query_id) records = cursor.fetchall() - self.e6x_connection.set_or_update_caches(False) + # self.e6x_connection.set_or_update_caches(False) now = time.time() query_id = cursor.execute(sql) logging.debug('Query Id {}'.format(query_id)) @@ -115,7 +108,7 @@ def test_query_5_caches(self): def test_query_6_explain_analyse(self): sql = "select * from date_dim limit 3" logging.debug('Executing query: {}'.format(sql)) - cursor = self.e6x_connection.cursor() + cursor = self.e6x_connection.cursor(catalog_name=self.catalog_name) query_id = cursor.execute(sql) cursor.explain_analyse() self.e6x_connection.close() @@ -123,7 +116,7 @@ def test_query_6_explain_analyse(self): def test_query_7_explain(self): sql = "select * from date_dim limit 3" logging.debug('Executing query: {}'.format(sql)) - cursor = self.e6x_connection.cursor() + cursor = self.e6x_connection.cursor(catalog_name=self.catalog_name) query_id = cursor.execute(sql) cursor.explain() self.e6x_connection.close() From c4ba733adcbc9d0b3012db864414ccde6ef9e738 Mon Sep 17 00:00:00 2001 From: Vishal Anand <101251245+vishale6x@users.noreply.github.com> Date: Tue, 8 Aug 2023 23:46:51 +0530 Subject: [PATCH 3/4] GRPC connection added. --- README.md | 17 ++++++++++------- setup.py | 2 ++ 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 0afa056..9a8ab14 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # e6data Python Connector -![version](https://img.shields.io/badge/version-1.0.10-blue.svg) +![version](https://img.shields.io/badge/version-1.1.0-blue.svg) ## Introduction @@ -21,7 +21,7 @@ pip install e6data-python-connector Use your e6data Email ID as the username and your access token as the password. ```python -import e6xdb.e6x as edb +from e6data_python_connector import Connection username = '' # Your e6data Email ID. password = '' # Access Token generated in the e6data console. @@ -29,8 +29,9 @@ password = '' # Access Token generated in the e6data console. host = '' # IP address or hostname of the cluster to be used. database = '' # # Database to perform the query on. port = 9000 # Port of the e6data engine. +catalog_name = '' -conn = edb.connect( +conn = Connection( host=host, port=port, username=username, @@ -45,7 +46,7 @@ conn = edb.connect( query = 'SELECT * FROM ' # Replace with the query. -cursor = conn.cursor() +cursor = conn.cursor(catalog_name=catalog_name) query_id = cursor.execute(query) # The execute function returns a unique query ID, which can be use to abort the query. all_records = cursor.fetchall() for row in all_records: @@ -91,7 +92,7 @@ cursor.cancel(query_id) Switch database in an existing connection: ```python database = '' # Replace with the new database. -cursor = conn.cursor(database) +cursor = conn.cursor(database, catalog_name) ``` ### Get Query Time Metrics @@ -99,7 +100,7 @@ cursor = conn.cursor(database) import json query = 'SELECT * FROM ' -cursor = conn.cursor() +cursor = conn.cursor(catalog_name) query_id = cursor.execute(query) # execute function returns query id, can be use for aborting th query. all_records = cursor.fetchall() @@ -159,6 +160,8 @@ port = 9000 # Port of the e6data engine. sql_query = 'SELECT * FROM ' # Replace with the actual query. +catalog_name = '' # Replace with the actual catalog name. + conn = edb.connect( host=host, port=port, @@ -167,7 +170,7 @@ conn = edb.connect( password=password ) -cursor = conn.cursor(db_name=database) +cursor = conn.cursor(db_name=database, catalog_name=catalog_name) query_id = cursor.execute(sql_query) all_records = cursor.fetchall() planner_result = json.loads(cursor.explain_analyse()) diff --git a/setup.py b/setup.py index b651e4a..ecc6801 100644 --- a/setup.py +++ b/setup.py @@ -44,6 +44,8 @@ def get_long_desc(): 'pycryptodome', 'pytz', 'thrift', + 'grpcio>=1.56.2', + 'grpcio-tools>=1.56.2', ], classifiers=[ "Operating System :: POSIX :: Linux", From 8f9724f47a0b1dd64ef3b9cb6ec01af8eadd2c96 Mon Sep 17 00:00:00 2001 From: Vishal Anand <101251245+vishale6x@users.noreply.github.com> Date: Tue, 8 Aug 2023 23:47:11 +0530 Subject: [PATCH 4/4] GRPC connection added. --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index ecc6801..b642fc4 100644 --- a/setup.py +++ b/setup.py @@ -16,7 +16,7 @@ envstring = lambda var: os.environ.get(var) or "" -VERSION = [1, 0, 10] +VERSION = [1, 1, 0] def get_long_desc():