gbase8sdb 0.2.1__cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

gbase8sdb/__init__.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+"""
+the package of gbase8sdb __init__ module
+"""
+
+import sys
+import collections
+
+apilevel = "2.0"
+paramstyle = "qmark"
+threadsafety = 2
+
+# version info
+from .version import __version__
+version = __version__
+
+# import GSDK
+# from . import driver, gsdk_driver
+from . import driver
+
+from .driver import (
+    DB_TYPE_BINARY_DOUBLE,
+    DB_TYPE_BINARY_FLOAT,
+    DB_TYPE_BINARY_INTEGER,
+    DB_TYPE_BLOB,
+    DB_TYPE_CHAR,
+    DB_TYPE_CLOB,
+    DB_TYPE_CURSOR,
+    DB_TYPE_DATE,   # map to TIMESTAMP
+    DB_TYPE_INTERVAL_DS,
+    DB_TYPE_INTERVAL_YM,
+    DB_TYPE_LONG_NVARCHAR,
+    DB_TYPE_NCHAR,
+    DB_TYPE_NCLOB,
+    DB_TYPE_NUMBER,
+    DB_TYPE_NVARCHAR,
+    DB_TYPE_TIMESTAMP,
+    DB_TYPE_TIMESTAMP_TZ,
+    DB_TYPE_VARCHAR,
+    # DB API
+    BINARY,
+    DATETIME,
+    NUMBER,
+    ROWID,
+    STRING,
+)
+
+
+from .exceptions import (
+    Warning as Warning,
+    Error as Error,
+    DatabaseError as DatabaseError,
+    DataError as DataError,
+    IntegrityError as IntegrityError,
+    InterfaceError as InterfaceError,
+    InternalError as InternalError,
+    NotSupportedError as NotSupportedError,
+    OperationalError as OperationalError,
+    ProgrammingError as ProgrammingError,
+)
+
+from .defaults import defaults
+
+from .connection import  connect, Connection
+
+from .cursor import  Cursor
+
+from .lob import LOB
+
+from .column_metadata import ColumnMetaData
+
+from .var import Var
+
+from .dsn import makedsn
+
+from .driver import load_gsdk as __load_gsdk, clientversion
+
+from .constructors import (
+    Binary as Binary,
+    Date as Date,
+    DateFromTicks as DateFromTicks,
+    Time as Time,
+    TimeFromTicks as TimeFromTicks,
+    Timestamp as Timestamp,
+    TimestampFromTicks as TimestampFromTicks,
+)
+
+
+IntervalYM = collections.namedtuple("IntervalYM", ["years", "months"])
+
+
+package = sys.modules[__name__]
+driver.init_driver(package)
+
+
+del package
+del sys
+del driver, connection, constructors
+del cursor, dsn, exceptions, column_metadata
+del lob
+del var
+
+__load_gsdk()
+
+
+__all__ = [
+    # defined in DB API
+    "apilevel", "paramstyle", "threadsafety", 
+    "BINARY", "DATETIME", "NUMBER", "ROWID", "STRING",
+    "Binary", "Date", "DateFromTicks", "Time", "TimeFromTicks", "Timestamp", "TimestampFromTicks",
+    "Warning", "Error", "DatabaseError", "DataError", "IntegrityError", "InterfaceError",
+    "InternalError", "NotSupportedError", "OperationalError", "ProgrammingError",
+    "connect", "Connection", 
+    # not define in DB API
+    "DB_TYPE_BINARY_DOUBLE", "DB_TYPE_BINARY_FLOAT", "DB_TYPE_BINARY_INTEGER", "DB_TYPE_BLOB",
+    "DB_TYPE_CHAR", "DB_TYPE_CLOB", "DB_TYPE_CURSOR", "DB_TYPE_DATE", "DB_TYPE_INTERVAL_DS",
+    "DB_TYPE_INTERVAL_YM", "DB_TYPE_LONG_NVARCHAR", "DB_TYPE_NCHAR", "DB_TYPE_NCLOB",
+    "DB_TYPE_NUMBER", "DB_TYPE_NVARCHAR", "DB_TYPE_TIMESTAMP", "DB_TYPE_TIMESTAMP_TZ", "DB_TYPE_VARCHAR",
+    "ColumnMetaData", "Var", "makedsn", "clientversion", "IntervalYM", 
+    "defaults", "Cursor", "LOB", "version"
+]

gbase8sdb/column_metadata.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+from typing import Union
+
+from . import __name__ as MODULE_NAME
+
+from .driver import (
+    DbType,
+    DB_TYPE_NUMBER,
+    DB_TYPE_BINARY_INTEGER,
+    DB_TYPE_BINARY_DOUBLE,
+    DB_TYPE_BINARY_FLOAT,
+    DB_TYPE_TIMESTAMP_TZ,
+    DB_TYPE_TIMESTAMP_LTZ,
+    DB_TYPE_TIMESTAMP,
+    DB_TYPE_DATE,
+
+)
+
+
+class ColumnMetaData:
+
+    __module__ = MODULE_NAME
+
+
+    def __str__(self):
+        return str(tuple(self))
+    
+    def __repr__(self):
+        return repr(tuple(self))
+
+
+    def __len__(self):
+        return 7
+
+    
+    def __eq__(self, other):
+        return tuple(self) == other
+    
+    def __getitem__(self, index):
+        description = (
+            self.name,
+            self.type_code,
+            self.display_size,
+            self.internal_size,
+            self.precision,
+            self.scale,
+            self.null_ok,
+        )
+        return description[index]
+
+    @classmethod
+    def _create_with_cyobj(cls, cyobj):
+        info = cls.__new__(cls)
+        info._type = None
+        info._cyobj = cyobj
+        return info
+    
+    @staticmethod
+    def _is_date_type(dbtype):
+        return dbtype in {DB_TYPE_DATE, DB_TYPE_TIMESTAMP, DB_TYPE_TIMESTAMP_LTZ, DB_TYPE_TIMESTAMP_TZ}
+
+    @staticmethod
+    def _is_numeric_type(dbtype):
+        return dbtype in {DB_TYPE_BINARY_FLOAT, DB_TYPE_BINARY_DOUBLE, DB_TYPE_BINARY_INTEGER, DB_TYPE_NUMBER}
+
+    @property
+    def internal_size(self):
+        if self._cyobj.size > 0:
+            return self._cyobj.buffer_size
+
+    @property
+    def is_json(self):
+        return self._cyobj.is_json
+
+    @property
+    def name(self) -> str:
+        return self._cyobj.name
+
+
+
+    @property
+    def precision(self) -> Union[int, None]:
+        if self._cyobj.precision or self._cyobj.scale:
+            return self._cyobj.precision
+
+
+
+    @property
+    def type(self) -> DbType:
+        if self._type is None:
+            self._type = self._cyobj.dbtype
+        return self._type
+
+    @property
+    def type_code(self) -> DbType:
+        return self._cyobj.dbtype
+    
+    @property
+    def display_size(self):
+        if self._cyobj.size > 0:
+            return self._cyobj.size
+        dbtype = self._cyobj.dbtype
+        if self._is_numeric_type(dbtype):
+            if self._cyobj.precision:
+                display_size = self._cyobj.precision + 1
+                if self._cyobj.scale > 0:
+                    display_size += self._cyobj.scale + 1
+            else:
+                display_size = 127
+            return display_size
+        elif self._is_date_type(dbtype):
+            return 23
+    
+    @property
+    def scale(self):
+        if self._cyobj.precision or self._cyobj.scale:
+            return self._cyobj.scale
+    
+    @property
+    def null_ok(self):
+        return self._cyobj.nulls_allowed

gbase8sdb/connection.py

@@ -0,0 +1,152 @@
+# coding: utf-8
+
+from . import __name__ as MODULE_NAME
+from typing import Callable, Union
+from . import errors
+from . import driver
+from .cursor import Cursor
+from .lob import LOB
+from .driver import DB_TYPE_BLOB, DB_TYPE_CLOB, DB_TYPE_NCLOB, DbType
+
+
+class Connection:
+    __module__ = MODULE_NAME
+
+    def __init__(self, dsn: str, user: str, password: str) -> None:
+        self._cyobj = None
+        self._version = None
+        cy_conn = driver.CyConnection(dsn, user, password)
+        cy_conn.connect()
+        self._cyobj = cy_conn
+        
+    def __repr__(self):
+        cls_name = f"{self.__class__.__module__}.{self.__class__.__qualname__}"
+        if self._cyobj is None:
+            return f"<{cls_name} disconnected>"
+        return f"<{cls_name} to {self.username}@{self.dsn}>"
+
+    def __del__(self):
+        if self._cyobj is not None:
+            self._cyobj.close(in_del=True)
+            self._cyobj = None
+
+    def __enter__(self):
+        self._verify_connected()
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        if self._cyobj is not None:
+            self._cyobj.close(in_del=True)
+            self._cyobj = None
+
+    def _verify_connected(self) -> None:
+        if self._cyobj is None:
+            errors.raise_error(errors.ERR_NOT_CONNECTED)   
+    
+    def close(self) -> None:
+        self._verify_connected()
+        self._cyobj.close()
+        self._cyobj = None
+
+    def commit(self) -> None:
+        self._verify_connected()
+        self._cyobj.commit()
+
+    def createlob(
+        self, lob_type: DbType, data: Union[str, bytes] = None
+    ) -> LOB:
+        self._verify_connected()
+        if lob_type not in (DB_TYPE_CLOB, DB_TYPE_NCLOB, DB_TYPE_BLOB):
+            message = (
+                "lob type should be one of gbase8sdb.DB_TYPE_BLOB, "
+                "gbase8sdb.DB_TYPE_CLOB or gbase8sdb.DB_TYPE_NCLOB"
+            )
+            raise TypeError(message)
+        impl = self._cyobj.create_temp_lob_impl(lob_type)
+        lob = LOB._create_with_cyobj(impl)
+        if data:
+            lob.write(data)
+        return lob
+
+    def cursor(self) -> Cursor:
+        self._verify_connected()
+        return Cursor(self)
+   
+    def ping(self) -> None:
+        self._verify_connected()
+        self._cyobj.ping()
+
+    def rollback(self) -> None:
+        self._verify_connected()
+        self._cyobj.rollback()
+        
+    def cancel(self) -> None:
+        self._verify_connected()
+        self._cyobj.cancel()
+        
+    @property
+    def autocommit(self) -> bool:
+        self._verify_connected()
+        return self._cyobj.autocommit
+
+    @autocommit.setter
+    def autocommit(self, value: bool) -> None:
+        self._verify_connected()
+        self._cyobj.autocommit = value
+
+    @property
+    def dsn(self) -> str:
+        self._verify_connected()
+        return self._cyobj.dsn
+
+    @property
+    def inputtypehandler(self) -> Callable:
+        self._verify_connected()
+        return self._cyobj.inputtypehandler
+
+    @inputtypehandler.setter
+    def inputtypehandler(self, value: Callable) -> None:
+        self._verify_connected()
+        self._cyobj.inputtypehandler = value
+
+
+    @property
+    def outputtypehandler(self) -> Callable:
+        self._verify_connected()
+        return self._cyobj.outputtypehandler
+
+    @outputtypehandler.setter
+    def outputtypehandler(self, value: Callable) -> None:
+        self._verify_connected()
+        self._cyobj.outputtypehandler = value
+
+    @property
+    def transaction_in_progress(self) -> bool:
+        self._verify_connected()
+        return self._cyobj.get_transaction_in_progress()
+
+    @property
+    def username(self) -> str:
+        self._verify_connected()
+        return self._cyobj.username
+
+    @property
+    def version(self) -> str:
+        if self._version is None:
+            self._verify_connected()
+            self._version = ".".join(str(c) for c in self._cyobj.server_version)
+        return self._version
+
+    @property
+    def warning(self) -> errors.ErrorWrapper:
+        self._verify_connected()
+        return self._cyobj.warning
+
+
+def connect(dsn: str, user: str, password: str) -> Connection:
+    """
+    创建数据库连接，并返回连接对象
+    """
+    if len(dsn) == 0 or len(user) == 0 or len(password) == 0:
+        raise errors.raise_error(errors.ERR_INVALID_CONNECT_PARAMS)
+    return Connection(dsn=dsn, user=user, password=password)

gbase8sdb/constructors.py

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+"""
+Database API functions
+"""
+import datetime
+from . import errors
+
+
+def Date(year: int, month: int, day: int) -> datetime.date:
+    return datetime.date(year, month, day)
+
+def Time(hour: int, minute: int, second: int) -> None:
+    errors.raise_error(errors.ERR_TIME_NOT_SUPPORTED)
+    
+def Timestamp(year: int, month: int, day: int, hour: int, minute: int, second: int) -> datetime.datetime:
+    return datetime.datetime(year, month, day, hour, minute, second)
+
+def DateFromTicks(ticks: float) -> datetime.date:
+    return datetime.date.fromtimestamp(ticks)
+
+
+def TimeFromTicks(ticks: float) -> None:
+    errors.raise_error(errors.ERR_TIME_NOT_SUPPORTED)
+
+
+def TimestampFromTicks(ticks: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(ticks)
+
+
+def Binary(value) -> bytes:
+    if isinstance(value, str):
+        return value.encode()
+    return bytes(value)