machbaseapi 2.0.0__py3-none-any.whl

machbaseAPI/__init__.py

@@ -0,0 +1,32 @@
+from .connector import (
+    DataError,
+    DatabaseError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    MachbaseConnection,
+    MachbaseCursor,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    Warning,
+    connect,
+)
+from .machbaseAPI import machbase, machbaseAPI
+
+__all__ = [
+    "connect",
+    "MachbaseConnection",
+    "MachbaseCursor",
+    "machbase",
+    "machbaseAPI",
+    "Error",
+    "Warning",
+    "InterfaceError",
+    "DatabaseError",
+    "OperationalError",
+    "IntegrityError",
+    "NotSupportedError",
+    "ProgrammingError",
+    "DataError",
+]

machbaseAPI/connector.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Iterable, List, Optional, Sequence
+
+from .errors import (
+    DataError,
+    DatabaseError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    Warning,
+)
+from .protocol import MachbaseProtocolClient
+
+
+_SELECT_PREFIX = re.compile(r"^\s*(SELECT|WITH|DESC|DESCRIBE|SHOW)\b", re.IGNORECASE)
+
+
+def connect(**kwargs: Any) -> "MachbaseConnection":
+    return MachbaseConnection(**kwargs)
+
+
+def _normalize_append_rows(
+    rows: Any,
+    *,
+    strict: bool = False,
+) -> List[Sequence[Any]]:
+    if rows is None:
+        return []
+    if isinstance(rows, str):
+        raise ProgrammingError("Append rows must be a sequence, not a string.")
+    if not isinstance(rows, (list, tuple)):
+        raise ProgrammingError("Append rows must be a sequence of rows.")
+
+    normalized = list(rows)
+    if len(normalized) == 0:
+        return []
+
+    if strict and not isinstance(normalized[0], (list, tuple)):
+        raise ProgrammingError("Append rows must be sequence objects when strict mode is enabled.")
+
+    if not isinstance(normalized[0], (list, tuple)):
+        return [tuple(normalized)]  # single row
+
+    if any(not isinstance(item, (list, tuple)) for item in normalized):
+        if strict:
+            raise ProgrammingError("Append rows must be a sequence of sequences when strict mode is enabled.")
+        raise ProgrammingError("Mixed append row type is not supported.")
+
+    return [tuple(item) for item in normalized]
+
+
+class MachbaseConnection:
+    _BANNED_POOL_KEYS = {"pool_name", "pool_size", "pool_reset_session"}
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 5656,
+        user: str = "SYS",
+        password: str = "MANAGER",
+        database: str = "data",
+        connect_timeout: int = 5,
+        query_timeout: int = 60,
+        autocommit: bool = True,
+        connection_string: str = "",
+        client_id: str = "PYMCB",
+        **kwargs: Any,
+    ):
+        for key in self._BANNED_POOL_KEYS:
+            if key in kwargs:
+                raise NotSupportedError(f"Pooling is not supported. Unsupported option: {key}")
+        if kwargs:
+            raise InterfaceError(f"Unknown connection option(s): {', '.join(sorted(kwargs.keys()))}")
+        if not autocommit:
+            raise NotSupportedError("Machbase is auto-commit only.")
+        show_hidden = "SHOW_HIDDEN_COLS=1" in connection_string.upper()
+        self._client = MachbaseProtocolClient(
+            host=host,
+            port=int(port),
+            user=user,
+            password=password,
+            database=database,
+            timeout_ms=int(connect_timeout) * 1000,
+            query_timeout_ms=int(query_timeout) * 1000,
+            client_id=client_id,
+            show_hidden_columns=show_hidden,
+        )
+        self._closed = False
+        self._result: Any = None
+        self._client.connect()
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._client.close()
+        self._closed = True
+
+    def is_connected(self) -> bool:
+        return not self._closed and self._client.connected
+
+    def commit(self) -> None:
+        raise NotSupportedError("Machbase transaction APIs are not supported.")
+
+    def rollback(self) -> None:
+        raise NotSupportedError("Machbase transaction APIs are not supported.")
+
+    def begin(self) -> None:
+        raise NotSupportedError("Machbase transaction APIs are not supported.")
+
+    def cursor(self, dictionary: bool = True, raw: bool = False) -> "MachbaseCursor":
+        return MachbaseCursor(self, dictionary=dictionary, raw=raw)
+
+    def execute(self, sql: str, params: Optional[Any] = None) -> "MachbaseCursor":
+        cursor = self.cursor()
+        cursor.execute(sql, params=params)
+        return cursor
+
+    def append(
+        self,
+        table: str,
+        rows: Iterable[Sequence[Any]],
+        *,
+        types: Optional[Sequence[int]] = None,
+        times: Optional[Sequence[Any]] = None,
+        date_format: str = "YYYY-MM-DD HH24:MI:SS",
+        strict: bool = False,
+    ) -> int:
+        _ = date_format
+        payload = _normalize_append_rows(rows, strict=strict)
+        if not payload:
+            return 0
+        count = self._client.append(table, payload, types=types, times=times)
+        self._result = {"table": table, "rows": count}
+        return count
+
+    def append_flush(self) -> None:
+        return None
+
+    def result(self) -> Any:
+        return self._result
+
+
+class MachbaseCursor:
+    def __init__(self, conn: MachbaseConnection, dictionary: bool = True, raw: bool = False):
+        self._conn = conn
+        self._dictionary = dictionary
+        self._raw = raw
+        self._rows: List[Any] = []
+        self._rowcount = -1
+        self._description = None
+
+    def execute(self, operation: str, params: Optional[Any] = None) -> "MachbaseCursor":
+        if self._conn._closed:
+            raise InterfaceError("Connection is closed.")
+        sql = _render_sql(operation, params)
+        if _SELECT_PREFIX.match(sql):
+            result = self._conn._client.query(sql)
+            self._description = tuple((col.name, None, None, None, None, None, None) for col in result.columns)
+            if self._raw:
+                self._rows = result.rows
+            elif self._dictionary:
+                self._rows = result.rows
+            else:
+                self._rows = [tuple(row[col.name] for col in result.columns) for row in result.rows]
+            self._rowcount = len(self._rows)
+            self._conn._result = result.rows
+        else:
+            result = self._conn._client.exec_direct(sql)
+            self._rows = []
+            self._rowcount = result.rows_affected
+            self._description = None
+            self._conn._result = {"rows_affected": result.rows_affected, "message": result.message}
+        return self
+
+    def executemany(self, operation: str, seq_of_params: Iterable[Any]) -> int:
+        count = 0
+        for params in seq_of_params:
+            self.execute(operation, params)
+            count += 1
+        return count
+
+    def fetchone(self) -> Optional[Any]:
+        if not self._rows:
+            return None
+        return self._rows.pop(0)
+
+    def fetchmany(self, size: int = 1) -> List[Any]:
+        out: List[Any] = []
+        for _ in range(size):
+            row = self.fetchone()
+            if row is None:
+                break
+            out.append(row)
+        return out
+
+    def fetchall(self) -> List[Any]:
+        rows = list(self._rows)
+        self._rows = []
+        return rows
+
+    def close(self) -> None:
+        self._rows = []
+
+    @property
+    def description(self):
+        return self._description
+
+    @property
+    def rowcount(self) -> int:
+        return self._rowcount
+
+
+def _render_sql(sql: str, params: Optional[Any]) -> str:
+    if params is None:
+        return sql
+    if isinstance(params, dict):
+        rendered = sql
+        for key, value in params.items():
+            rendered = rendered.replace(f"%({key})s", _render_value(value))
+        return rendered
+    if not isinstance(params, (list, tuple)):
+        params = (params,)
+    parts = sql.split("%s")
+    if len(parts) - 1 != len(params):
+        raise ProgrammingError("Parameter count does not match placeholders.")
+    chunks: List[str] = []
+    for index, part in enumerate(parts[:-1]):
+        chunks.append(part)
+        chunks.append(_render_value(params[index]))
+    chunks.append(parts[-1])
+    return "".join(chunks)
+
+
+def _render_value(value: Any) -> str:
+    if value is None:
+        return "NULL"
+    if isinstance(value, bool):
+        return "1" if value else "0"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, str):
+        return "'" + value.replace("'", "''") + "'"
+    if isinstance(value, (list, tuple, dict)):
+        return "'" + json.dumps(value, ensure_ascii=False).replace("'", "''") + "'"
+    return "'" + str(value).replace("'", "''") + "'"

machbaseAPI/conntest.py

@@ -0,0 +1,27 @@
+#******************************************************************************
+# Copyright of this product 2013-2023,
+# MACHBASE Corporation(or Inc.) or its subsidiaries.
+# All Rights reserved.
+#******************************************************************************
+
+import os
+from machbaseAPI.machbaseAPI import machbase
+
+def connect():
+    port = int(os.environ['MACHBASE_PORT_NO'])
+    db = machbase()
+    if db.open('192.168.0.148','SYS','MANAGER',port) == 0 :
+        return db.result()
+
+    if db.execute('select count(*) from m$tables') == 0 :
+        return db.result()
+
+    result = db.result()
+
+    if db.close() == 0 :
+        return db.result()
+
+    return result
+
+if __name__=="__main__":
+    print(connect())

machbaseAPI/constants.py

@@ -0,0 +1,189 @@
+"""Machbase native protocol constants."""
+
+CMI_PACKET_MAX_BODY = 64 * 1024
+
+CMI_PROTO_CNT = 9
+CMI_HANDSHAKE_PREFIX = "CMI_INET"
+CMI_HANDSHAKE_ENDIAN_LITTLE = "0"
+CMI_HANDSHAKE_READY = "CMI_READY"
+
+CMI_PROTOCOL_MAJOR_VERSION = 4
+CMI_PROTOCOL_MINOR_VERSION = 0
+CMI_PROTOCOL_FIX_VERSION = 0
+
+CMI_CONNECT_PROTOCOL = 0
+CMI_DISCONNECT_PROTOCOL = 1
+CMI_INVALID_PROTOCOL = 2
+CMI_LARGE_PROTOCOL = 3
+CMI_TIMEOUT_PROTOCOL = 4
+CMI_ADMIN_PROTOCOL = 5
+CMI_PREPARE_PROTOCOL = 6
+CMI_EXECUTE_PROTOCOL = 7
+CMI_EXECDIRECT_PROTOCOL = 8
+CMI_FETCH_PROTOCOL = 9
+CMI_FREE_PROTOCOL = 10
+CMI_APPEND_OPEN_PROTOCOL = 11
+CMI_APPEND_DATA_PROTOCOL = 12
+CMI_APPEND_CLOSE_PROTOCOL = 13
+CMI_COLLECTOR_MANAGER_PROTOCOL = 14
+CMI_COLLECTOR_META_PROTOCOL = 15
+CMI_COLLECTOR_SOURCE_PROTOCOL = 16
+CMI_MSG_PROTOCOL = 17
+CMI_EXECARRAY_PROTOCOL = 18
+CMI_APPEND_BATCH_PROTOCOL = 19
+
+CMI_C_VERSION_ID = 0x00000001
+CMI_C_CLIENT_ID = 0x00000002
+CMI_C_LANG_ID = 0x00000003
+CMI_C_DATABASE_ID = 0x00000004
+CMI_C_ENDIAN_ID = 0x00000005
+CMI_C_USER_ID = 0x00000006
+CMI_C_PASSWORD_ID = 0x00000007
+CMI_C_TIMEOUT_ID = 0x00000008
+CMI_C_SLANG_ID = 0x00000009
+CMI_C_SID_ID = 0x00000040
+CMI_C_SHC_ID = 0x00000041
+CMI_C_IP_ID = 0x00000042
+CMI_C_NODE_STATE = 0x00000050
+CMI_C_TIMEZONE_ID = 0x00000070
+
+CMI_R_RESULT_ID = 0x00000010
+CMI_R_MESSAGE_ID = 0x00000011
+CMI_R_EMESSAGE_ID = 0x00000012
+
+CMI_P_STATEMENT_ID = 0x00000020
+CMI_P_BINDS_ID = 0x00000021
+CMI_P_ID_ID = 0x00000022
+CMI_P_ROWS_ID = 0x00000023
+CMI_P_COLUMNS_ID = 0x00000024
+CMI_P_TABLE_ID = 0x00000025
+CMI_P_COLNAME_ID = 0x00000026
+CMI_P_COLTYPE_ID = 0x00000027
+CMI_P_DDF_ID = 0x00000028
+CMI_P_PARAMTYPE_ID = 0x00000029
+
+CMI_E_BIND_ID = 0x00000030
+CMI_E_PARAM_ID = 0x00000031
+CMI_E_OUTPARAM_ID = 0x00000032
+CMI_E_ENDIAN_ID = 0x00000034
+CMI_E_EXECARRAY_RESULT_ID = 0x00000035
+
+CMI_D_STATEMENT_ID = 0x00000040
+
+CMI_F_ID_ID = 0x00000050
+CMI_F_ROWS_ID = 0x00000051
+CMI_F_VALUE_ID = 0x00000052
+
+CMI_X_ID_ID = 0x00000060
+CMI_X_APPEND_SUCCESS_ID = 0x00000061
+CMI_X_APPEND_FAILURE_ID = 0x00000062
+CMI_L_ERROR_ROWS_ID = 0x00000063
+
+CMI_STRING_TYPE = 0x00000002
+CMI_BINARY_TYPE = 0x00000003
+CMI_SCHAR_TYPE = 0x00000004
+CMI_UCHAR_TYPE = 0x00000005
+CMI_SSHORT_TYPE = 0x00000006
+CMI_USHORT_TYPE = 0x00000007
+CMI_SINT_TYPE = 0x00000008
+CMI_UINT_TYPE = 0x00000009
+CMI_SLONG_TYPE = 0x0000000A
+CMI_ULONG_TYPE = 0x0000000B
+CMI_DATE_TYPE = 0x0000000C
+CMI_ROWS_TYPE = 0x0000000D
+CMI_TNUMERIC_TYPE = 0x000000F1
+CMI_NUMBER_TYPE = 0x000000F2
+
+CMI_OK_RESULT = 0x724F4B5F00000000
+CMI_CM_ERROR_RESULT = 0x72434D5F00000000
+CMI_LAST_RESULT = 0x724C535400000000
+CMI_TIMEOUT_RESULT = 0x7254494D00000000
+CMI_LARGE_RESULT = 0x724C524700000000
+CMI_INVALID_RESULT = 0x72494E5600000000
+
+CMD_FIX_FLAG = 0x0000
+CMD_VAR_FLAG = 0x0001
+CMD_TIME_FLAG = 0x0002
+
+CMD_VARCHAR_TYPE = (0x0001 << 2) | CMD_VAR_FLAG
+CMD_DATE_TYPE = (0x0001 << 2) | CMD_TIME_FLAG
+CMD_INT16_TYPE = (0x0001 << 2) | CMD_FIX_FLAG
+CMD_INT32_TYPE = (0x0002 << 2) | CMD_FIX_FLAG
+CMD_INT64_TYPE = (0x0003 << 2) | CMD_FIX_FLAG
+CMD_FLT32_TYPE = (0x0004 << 2) | CMD_FIX_FLAG
+CMD_FLT64_TYPE = (0x0005 << 2) | CMD_FIX_FLAG
+CMD_NUL_TYPE = (0x0006 << 2) | CMD_FIX_FLAG
+CMD_IPV4_TYPE = (0x0008 << 2) | CMD_FIX_FLAG
+CMD_IPV6_TYPE = (0x0009 << 2) | CMD_FIX_FLAG
+CMD_BOOL_TYPE = (0x000A << 2) | CMD_FIX_FLAG
+CMD_CHAR_TYPE = (0x000B << 2) | CMD_VAR_FLAG
+CMD_TEXT_TYPE = (0x000C << 2) | CMD_VAR_FLAG
+CMD_CLOB_TYPE = (0x000D << 2) | CMD_VAR_FLAG
+CMD_BLOB_TYPE = (0x000E << 2) | CMD_VAR_FLAG
+CMD_JSON_TYPE = (0x000F << 2) | CMD_VAR_FLAG
+CMD_BINARY_TYPE = (0x0018 << 2) | CMD_VAR_FLAG
+CMD_IPNET_TYPE = (0x0019 << 2) | CMD_VAR_FLAG
+CMD_UINT16_TYPE = (0x001A << 2) | CMD_FIX_FLAG
+CMD_UINT32_TYPE = (0x001B << 2) | CMD_FIX_FLAG
+CMD_UINT64_TYPE = (0x001C << 2) | CMD_FIX_FLAG
+
+SQL_APPEND_TYPE_NULL = 0
+SQL_APPEND_TYPE_INT16 = 1
+SQL_APPEND_TYPE_INT32 = 2
+SQL_APPEND_TYPE_INT64 = 3
+SQL_APPEND_TYPE_UINT16 = 4
+SQL_APPEND_TYPE_UINT32 = 5
+SQL_APPEND_TYPE_UINT64 = 6
+SQL_APPEND_TYPE_FLT32 = 7
+SQL_APPEND_TYPE_FLT64 = 8
+SQL_APPEND_TYPE_IPV4 = 9
+SQL_APPEND_TYPE_IPV6 = 10
+SQL_APPEND_TYPE_DATE = 11
+SQL_APPEND_TYPE_VARCHAR = 12
+SQL_APPEND_TYPE_CLOB = 13
+SQL_APPEND_TYPE_BLOB = 14
+SQL_APPEND_TYPE_JSON = 15
+
+CMI_APPEND_TYPE_MAP = {
+    SQL_APPEND_TYPE_NULL: CMD_NUL_TYPE,
+    SQL_APPEND_TYPE_INT16: CMD_INT16_TYPE,
+    SQL_APPEND_TYPE_INT32: CMD_INT32_TYPE,
+    SQL_APPEND_TYPE_INT64: CMD_INT64_TYPE,
+    SQL_APPEND_TYPE_UINT16: CMD_UINT16_TYPE,
+    SQL_APPEND_TYPE_UINT32: CMD_UINT32_TYPE,
+    SQL_APPEND_TYPE_UINT64: CMD_UINT64_TYPE,
+    SQL_APPEND_TYPE_FLT32: CMD_FLT32_TYPE,
+    SQL_APPEND_TYPE_FLT64: CMD_FLT64_TYPE,
+    SQL_APPEND_TYPE_IPV4: CMD_IPV4_TYPE,
+    SQL_APPEND_TYPE_IPV6: CMD_IPV6_TYPE,
+    SQL_APPEND_TYPE_DATE: CMD_DATE_TYPE,
+    SQL_APPEND_TYPE_VARCHAR: CMD_VARCHAR_TYPE,
+    SQL_APPEND_TYPE_CLOB: CMD_CLOB_TYPE,
+    SQL_APPEND_TYPE_BLOB: CMD_BLOB_TYPE,
+    SQL_APPEND_TYPE_JSON: CMD_JSON_TYPE,
+    4: CMD_INT16_TYPE,
+    8: CMD_INT32_TYPE,
+    12: CMD_INT64_TYPE,
+    16: CMD_FLT32_TYPE,
+    20: CMD_FLT64_TYPE,
+    32: CMD_DATE_TYPE,
+    36: CMD_UINT64_TYPE,
+    49: CMD_TEXT_TYPE,
+    61: CMD_DATE_TYPE,
+    97: CMD_BINARY_TYPE,
+    104: CMD_UINT16_TYPE,
+    108: CMD_UINT32_TYPE,
+    112: CMD_UINT64_TYPE,
+    2104: CMD_IPV4_TYPE,
+    2106: CMD_IPV6_TYPE,
+    2110: CMD_JSON_TYPE,
+    2111: CMD_BINARY_TYPE,
+}
+
+
+def is_variable_type(spiner_type: int) -> bool:
+    return (spiner_type & CMD_VAR_FLAG) == CMD_VAR_FLAG
+
+
+DEFAULT_CONNECT_TIMEOUT_MS = 5000
+DEFAULT_QUERY_TIMEOUT_MS = 60000

machbaseAPI/errors.py

@@ -0,0 +1,38 @@
+"""Error hierarchy for the pure-Python Machbase connector."""
+
+
+class Error(Exception):
+    """Base class for all public connector errors."""
+
+
+class Warning(Error):
+    """Warning is kept for compatibility with DB-API style naming."""
+
+
+class InterfaceError(Error):
+    """Invalid public interface usage."""
+
+
+class DatabaseError(Error):
+    """Server-side or protocol error."""
+
+
+class OperationalError(DatabaseError):
+    """Connection / network errors."""
+
+
+class IntegrityError(DatabaseError):
+    """Data integrity violations."""
+
+
+class DataError(DatabaseError):
+    """Data conversion / encoding errors."""
+
+
+class ProgrammingError(DatabaseError):
+    """Invalid arguments or method usage."""
+
+
+class NotSupportedError(DatabaseError):
+    """Unsupported feature requested by caller."""
+