mapepire-python 0.1.3__py3-none-any.whl

mapepire_python/client/query.py

@@ -0,0 +1,132 @@
+import json
+from enum import Enum
+from typing import Any, Dict, Generic, List, Optional, TypeVar, Union
+
+from ..types import QueryOptions
+from .sql_job import SQLJob
+
+T = TypeVar("T")
+
+
+class QueryState(Enum):
+    NOT_YET_RUN = (1,)
+    RUN_MORE_DATA_AVAIL = (2,)
+    RUN_DONE = (3,)
+    ERROR = 4
+
+
+def get_query_options(opts: Optional[Union[Dict[str, Any], QueryOptions]] = None) -> QueryOptions:
+    if isinstance(opts, QueryOptions):
+        return opts
+    elif opts:
+        return QueryOptions(**opts)
+    else:
+        return QueryOptions(isClCommand=False, parameters=None, autoClose=False)
+
+
+class Query(Generic[T]):
+    global_query_list: List["Query[Any]"] = []
+
+    def __init__(self, job: SQLJob, query: str, opts: QueryOptions) -> None:
+        self.job = job
+        self.is_prepared: bool = True if opts.parameters is not None else False
+        self.parameters: Optional[List[str]] = opts.parameters
+        self.sql: str = query
+        self.is_cl_command: Optional[bool] = opts.isClCommand
+        self.should_auto_close: Optional[bool] = opts.autoClose
+        self.is_terse_results: Optional[bool] = opts.isTerseResults
+
+        self._rows_to_fetch: int = 100
+        self.state: QueryState = QueryState.NOT_YET_RUN
+
+        Query.global_query_list.append(self)
+
+    def run(self, rows_to_fetch: Optional[int] = None) -> Dict[str, Any]:
+        if rows_to_fetch is None:
+            rows_to_fetch = self._rows_to_fetch
+        else:
+            self._rows_to_fetch = rows_to_fetch
+
+        # check Query state first
+        if self.state == QueryState.RUN_MORE_DATA_AVAIL:
+            raise Exception("Statement has already been run")
+        elif self.state == QueryState.RUN_DONE:
+            raise Exception("Statement has already been fully run")
+
+        query_object: Dict[str, Any] = {}
+        if self.is_cl_command:
+            query_object = {
+                "id": self.job._get_unique_id("clcommand"),
+                "type": "cl",
+                "terse": self.is_terse_results,
+                "cmd": self.sql,
+            }
+        else:
+            query_object = {
+                "id": self.job._get_unique_id("query"),
+                "type": "prepare_sql_execute" if self.is_prepared else "sql",
+                "sql": self.sql,
+                "terse": self.is_terse_results,
+                "rows": rows_to_fetch,
+                "parameters": self.parameters,
+            }
+
+        self.job.send(json.dumps(query_object))
+        query_result: Dict[str, Any] = json.loads(self.job._socket.recv())
+
+        self.state = (
+            QueryState.RUN_DONE
+            if query_result.get("is_done", False)
+            else QueryState.RUN_MORE_DATA_AVAIL
+        )
+
+        if not query_result.get("success", False) and not self.is_cl_command:
+            print(query_result)
+            self.state = QueryState.ERROR
+            error_keys = ["error", "sql_state", "sql_rc"]
+            error_list = {
+                key: query_result[key] for key in error_keys if key in query_result.keys()
+            }
+            if len(error_list) == 0:
+                error_list["error"] = "failed to run query for unknown reason"
+
+            raise Exception(error_list)
+
+        self._correlation_id = query_result["id"]
+
+        return query_result
+
+    def fetch_more(self, rows_to_fetch: Optional[int] = None) -> Dict[str, Any]:
+        if rows_to_fetch is None:
+            rows_to_fetch = self._rows_to_fetch
+        else:
+            self._rows_to_fetch = rows_to_fetch
+
+        if self.state == QueryState.NOT_YET_RUN:
+            raise Exception("Statement has not been run")
+        elif self.state == QueryState.RUN_DONE:
+            raise Exception("Statement has already been fully run")
+
+        query_object = {
+            "id": self.job._get_unique_id("fetchMore"),
+            "cont_id": self._correlation_id,
+            "type": "sqlmore",
+            "sql": self.sql,
+            "rows": rows_to_fetch,
+        }
+
+        self._rows_to_fetch = rows_to_fetch
+        self.job.send(json.dumps(query_object))
+        query_result: Dict[str, Any] = json.loads(self.job._socket.recv())
+
+        self.state = (
+            QueryState.RUN_DONE
+            if query_result.get("is_done", False)
+            else QueryState.RUN_MORE_DATA_AVAIL
+        )
+
+        if not query_result["success"]:
+            self.state = QueryState.ERROR
+            raise Exception(query_result["error"] or "Failed to run Query (unknown error)")
+
+        return query_result

mapepire_python/client/sql_job.py

@@ -0,0 +1,130 @@
+import base64
+import json
+import ssl
+from typing import Any, Dict, Optional, Union
+
+from websocket import WebSocket, create_connection
+
+from ..types import DaemonServer, JobStatus, QueryOptions
+
+
+class SQLJob:
+    def __init__(self, options: Dict[Any, Any] = {}) -> None:
+        self.options = options
+        self._unique_id_counter: int = 0
+        self._reponse_emitter = None
+        self._status: JobStatus = JobStatus.NotStarted
+        self._trace_file = None
+        self._is_tracing_channeldata: bool = True
+
+        self.__unique_id = self._get_unique_id("sqljob")
+        self.id: Optional[str] = None
+
+    def _get_unique_id(self, prefix: str = "id") -> str:
+        self._unique_id_counter += 1
+        return f"{prefix}{self._unique_id_counter}"
+
+    def _get_channel(self, db2_server: DaemonServer) -> WebSocket:
+        uri = f"wss://{db2_server.host}:{db2_server.port}/db/"
+        headers = {
+            "Authorization": "Basic "
+            + base64.b64encode(f"{db2_server.user}:{db2_server.password}".encode()).decode("ascii")
+        }
+
+        # Prepare SSL context if necessary
+        ssl_opts: Dict[str, Any] = {}
+        if db2_server.ignoreUnauthorized:
+            ssl_opts["cert_reqs"] = ssl.CERT_NONE
+        if db2_server.ca:
+            ssl_context = ssl.create_default_context(cadata=db2_server.ca)
+            ssl_context.check_hostname = False
+            ssl_opts["ssl_context"] = ssl_context
+            ssl_opts["cert_reqs"] = ssl.CERT_NONE  # ignore certs for now
+
+        # Create WebSocket connection
+        socket = create_connection(uri, header=headers, sslopt=ssl_opts)
+
+        return socket
+
+    def send(self, content):
+        self._socket.send(content)
+
+    def connect(self, db2_server: DaemonServer) -> Dict[Any, Any]:
+        self._socket: WebSocket = self._get_channel(db2_server)
+
+        props = ";".join(
+            [
+                f'{prop}={",".join(self.options[prop]) if isinstance(self.options[prop], list) else self.options[prop]}'
+                for prop in self.options
+            ]
+        )
+
+        connection_props = {
+            "id": self._get_unique_id(),
+            "type": "connect",
+            "technique": "tcp",
+            "application": "Python Client",
+            "props": props if len(props) > 0 else "",
+        }
+
+        self.send(json.dumps(connection_props))
+        result: Dict[str, Any] = {}
+        try:
+            result = json.loads(self._socket.recv())
+        except Exception as e:
+            print(f"an error occured while loading connect result: {e}")
+
+        if result.get("success", False):
+            self._status = JobStatus.Ready
+        else:
+            self._status = JobStatus.NotStarted
+            raise Exception(result.get("error", "Failed to connect to server"))
+
+        self.id = result["job"]
+        self._is_tracing_channeldata = False
+
+        return result
+
+    def query(
+        self,
+        sql: str,
+        opts: Optional[Union[Dict[str, Any], QueryOptions]] = None,
+    ):
+        """
+        Create a Query object using provided SQL and options. If opts is None,
+        the default options defined in Query constructor are used. opts can be a
+        dictionary to be converted to QueryOptions, or a QueryOptions object directly.
+
+        Args:
+        sql (str): The SQL query string.
+        opts (Optional[Union[Dict[str, Any], QueryOptions]]): Additional options
+                for the query which can be a dictionary or a QueryOptions object.
+
+        Returns:
+        Query: A configured Query object.
+        """
+        from .query import Query
+
+        if opts is not None and not isinstance(opts, (dict, QueryOptions)):
+            raise ValueError("opts must be a dictionary, a QueryOptions object, or None")
+
+        query_options = (
+            opts
+            if isinstance(opts, QueryOptions)
+            else (
+                QueryOptions(**opts)
+                if opts
+                else QueryOptions(isClCommand=False, parameters=None, autoClose=False)
+            )
+        )
+
+        return Query(job=self, query=sql, opts=query_options)
+
+    def query_and_run(
+        self, sql: str, opts: Optional[Dict[str, Any]] = None, **kwargs
+    ) -> Dict[str, Any]:
+        query = self.query(sql, opts)
+        return query.run(**kwargs)
+
+    def close(self):
+        self._socket.close()

mapepire_python/pool.py

@@ -0,0 +1,29 @@
+# from dataclasses import dataclass
+# from typing import List, Optional
+
+
+# from mapepire_python.client.sql_job import SQLJob
+# from mapepire_python.types import *
+
+
+# @dataclass
+# class PoolOptions:
+#     creds: DaemonServer
+#     opts: Optional[JDBCOptions]
+#     max_size: int
+#     starting_size: int
+
+
+# class Pool:
+#     def __init__(self, options: PoolOptions) -> None:
+#         self.options = options
+#         self.jobs: List[SQLJob] = []
+
+#     def init(self):
+#         ...
+
+#     async def add_job(self):
+#         new_job = SQLJob(self.options.opts)
+#         self.jobs.append(new_job)
+#         new_job.connect(self.options.creds)
+#         return new_job

mapepire_python/ssl.py

@@ -0,0 +1,19 @@
+import socket
+import ssl
+from typing import Optional
+
+from .types import DaemonServer
+
+
+def get_certificate(creds: DaemonServer) -> Optional[bytes]:
+    context = ssl.create_default_context()
+    context.check_hostname = False
+    context.verify_mode = ssl.CERT_NONE
+
+    if creds.ca:
+        context.load_verify_locations(
+            cadata=creds.ca if isinstance(creds.ca, str) else creds.ca.decode()
+        )
+    with socket.create_connection((creds.host, creds.port)) as sock:
+        with context.wrap_socket(sock, server_hostname=creds.host) as ssock:
+            return ssock.getpeercert(binary_form=True)

mapepire_python/types.py

@@ -0,0 +1,239 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, List, Optional, Union
+
+from dataclasses_json import dataclass_json
+
+
+class JobStatus(Enum):
+    NotStarted = "notStarted"
+    Ready = "ready"
+    Busy = "busy"
+    Ended = "ended"
+
+
+class ExplainType(Enum):
+    Run = 0
+    DoNotRun = 1
+
+
+class TransactionEndType(Enum):
+    COMMIT = 0
+    ROLLBACK = 1
+
+
+class ServerTraceLevel(Enum):
+    OFF = "OFF"
+    ON = "ON"
+    ERRORS = "ERRORS"
+    DATASTREAM = "DATASTREAM"
+
+
+class ServerTraceDest(Enum):
+    FILE = "FILE"
+    IN_MEM = "IN_MEM"
+
+
+@dataclass
+class DaemonServer:
+    host: str
+    user: str
+    password: str
+    port: int
+    ignoreUnauthorized: Optional[bool] = None
+    ca: Optional[Union[str, bytes]] = None
+
+
+@dataclass_json
+@dataclass
+class ServerResponse:
+    id: str
+    success: bool
+    sql_rc: int
+    sql_state: str
+    error: Optional[str] = None
+
+
+@dataclass_json
+@dataclass
+class ConnectionResult(ServerResponse):
+    job: str
+    id: str = field(init=False)
+    success: bool = field(init=False)
+    sql_rc: int = field(init=False)
+    sql_state: str = field(init=False)
+    error: Optional[str] = field(default=None, init=False)
+
+
+@dataclass_json
+@dataclass
+class VersionCheckResult(ServerResponse):
+    build_date: str
+    version: str
+    id: str = field(init=False)
+    success: bool = field(init=False)
+    sql_rc: int = field(init=False)
+    sql_state: str = field(init=False)
+    error: Optional[str] = field(default=None, init=False)
+
+
+@dataclass
+class ColumnMetaData:
+    display_size: int
+    label: str
+    name: str
+    type: str
+
+
+@dataclass
+class QueryMetaData:
+    column_count: int
+    columns: List[ColumnMetaData]
+    job: str
+
+
+@dataclass
+class QueryResult:
+    metadata: QueryMetaData
+    is_done: bool
+    has_results: bool
+    update_count: int
+    data: List[Any]
+
+
+@dataclass
+class ExplainResults(QueryResult):
+    vemetadata: QueryMetaData
+    vedata: Any
+
+
+@dataclass_json
+@dataclass
+class GetTraceDataResult(ServerResponse):
+    tracedata: str
+    id: str = field(init=False)
+    success: bool = field(init=False)
+    sql_rc: int = field(init=False)
+    sql_state: str = field(init=False)
+    error: Optional[str] = field(default=None, init=False)
+
+
+@dataclass
+class JobLogEntry:
+    MESSAGE_ID: str
+    SEVERITY: str
+    MESSAGE_TIMESTAMP: str
+    FROM_LIBRARY: str
+    FROM_PROGRAM: str
+    MESSAGE_TYPE: str
+    MESSAGE_TEXT: str
+    MESSAGE_SECOND_LEVEL_TEXT: str
+
+
+@dataclass_json
+@dataclass
+class CLCommandResult(ServerResponse):
+    joblog: List[JobLogEntry]
+    id: str = field(init=False)
+    success: bool = field(init=False)
+    sql_rc: int = field(init=False)
+    sql_state: str = field(init=False)
+    error: Optional[str] = field(default=None, init=False)
+
+
+@dataclass
+class QueryOptions:
+    isTerseResults: Optional[bool] = None
+    isClCommand: Optional[bool] = None
+    parameters: Optional[List[str]] = None
+    autoClose: Optional[bool] = None
+
+
+@dataclass_json
+@dataclass
+class SetConfigResult(ServerResponse):
+    tracedest: ServerTraceDest
+    tracelevel: ServerTraceLevel
+    id: str = field(init=False)
+    success: bool = field(init=False)
+    sql_rc: int = field(init=False)
+    sql_state: str = field(init=False)
+    error: Optional[str] = field(default=None, init=False)
+
+
+@dataclass
+class JDBCOptions:
+    naming: Optional[str] = None
+    date_format: Optional[str] = None
+    date_separator: Optional[str] = None
+    decimal_separator: Optional[str] = None
+    time_format: Optional[str] = None
+    time_separator: Optional[str] = None
+    full_open: Optional[bool] = None
+    access: Optional[str] = None
+    autocommit_exception: Optional[bool] = None
+    bidi_string_type: Optional[str] = None
+    bidi_implicit_reordering: Optional[bool] = None
+    bidi_numeric_ordering: Optional[bool] = None
+    data_truncation: Optional[bool] = None
+    driver: Optional[str] = None
+    errors: Optional[str] = None
+    extended_metadata: Optional[bool] = None
+    hold_input_locators: Optional[bool] = None
+    hold_statements: Optional[bool] = None
+    ignore_warnings: Optional[str] = None
+    keep_alive: Optional[bool] = None
+    key_ring_name: Optional[str] = None
+    key_ring_password: Optional[str] = None
+    metadata_source: Optional[str] = None
+    proxy_server: Optional[str] = None
+    remarks: Optional[str] = None
+    secondary_URL: Optional[str] = None
+    secure: Optional[bool] = None
+    server_trace: Optional[str] = None
+    thread_used: Optional[bool] = None
+    toolbox_trace: Optional[str] = None
+    trace: Optional[bool] = None
+    translate_binary: Optional[bool] = None
+    translate_boolean: Optional[bool] = None
+    libraries: Optional[List[str]] = None
+    auto_commit: Optional[bool] = None
+    concurrent_access_resolution: Optional[str] = None
+    cursor_hold: Optional[bool] = None
+    cursor_sensitivity: Optional[str] = None
+    database_name: Optional[str] = None
+    decfloat_rounding_mode: Optional[str] = None
+    maximum_precision: Optional[str] = None
+    maximum_scale: Optional[str] = None
+    minimum_divide_scale: Optional[str] = None
+    package_ccsid: Optional[str] = None
+    transaction_isolation: Optional[str] = None
+    translate_hex: Optional[str] = None
+    true_autocommit: Optional[bool] = None
+    XA_loosely_coupled_support: Optional[str] = None
+    big_decimal: Optional[bool] = None
+    block_criteria: Optional[str] = None
+    block_size: Optional[str] = None
+    data_compression: Optional[bool] = None
+    extended_dynamic: Optional[bool] = None
+    lazy_close: Optional[bool] = None
+    lob_threshold: Optional[str] = None
+    maximum_blocked_input_rows: Optional[str] = None
+    package: Optional[str] = None
+    package_add: Optional[bool] = None
+    package_cache: Optional[bool] = None
+    package_criteria: Optional[str] = None
+    package_error: Optional[str] = None
+    package_library: Optional[str] = None
+    prefetch: Optional[bool] = None
+    qaqqinilib: Optional[str] = None
+    query_optimize_goal: Optional[str] = None
+    query_timeout_mechanism: Optional[str] = None
+    query_storage_limit: Optional[str] = None
+    receive_buffer_size: Optional[str] = None
+    send_buffer_size: Optional[str] = None
+    variable_field_compression: Optional[bool] = None
+    sort: Optional[str] = None
+    sort_language: Optional[str] = None
+    sort_table: Optional[str] = None
+    sort_weight: Optional[str] = None

mapepire_python/version.py

@@ -0,0 +1,11 @@
+_MAJOR = "0"
+_MINOR = "1"
+# On main and in a nightly release the patch should be one ahead of the last
+# released build.
+_PATCH = "3"
+# This is mainly for nightly builds which have the suffix ".dev$DATE". See
+# https://semver.org/#is-v123-a-semantic-version for the semantics.
+_SUFFIX = ""
+
+VERSION_SHORT = "{0}.{1}".format(_MAJOR, _MINOR)
+VERSION = "{0}.{1}.{2}{3}".format(_MAJOR, _MINOR, _PATCH, _SUFFIX)