gbase8sdb 1.0.0__tar.gz

gbase8sdb-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2025 GBASE Technologies Co.,Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gbase8sdb-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include MANIFEST.in
+recursive-include src/gbase8sdb *.pxd
+recursive-include src/gbase8sdb *.pxi
+recursive-include src/gbase8sdb *.pyx

gbase8sdb-1.0.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: gbase8sdb
+Version: 1.0.0
+Summary: Python interface to GBase 8s Database
+Home-page: UNKNOWN
+License: UNKNOWN
+Keywords: GBase 8s,database
+Platform: UNKNOWN
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Database
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# python-gbase8sdb
+
+python-gbase8sdb 是一个 [Python 编程语言][python] 扩展模块，允许 Python 程序连接到 GBase 8s 数据库。
+
+该模块符合 [Python 数据库 API 2.0 规范][pep249]，并且包含大量扩展和少数排除项。
+
+
+## 安装
+
+运行 `python -m pip install gbase8sdb` 安装。
+
+
+## 依赖和互操作性
+
+- 支持的 GBase 8s 数据库版本：GBase 8s V8.8_3.6.2版本及以上。
+
+- 支持的操作系统：Linux x86_64、 Linux AArch64、 Windows 64位操作系统 。
+
+
+#### 使用说明
+
+
+#### 入门
+在您的Python应用程序中，可以通过以下方式连接到数据库：
+```python
+import gbase8sdb
+
+# 生成数据库连接字符串
+dsn = gbase8sdb.makedsn(
+    db_name="testdbutf8",               # 数据库名称，如果不连库，设置为None
+    host="192.168.xxx.xxx",             # 数据库实例所在服务器的IP地址或域名，连接组时不需要提供此参数
+    port=9088,                          # 数据库实例的端口号，连接组时不需要提供此参数
+    db_locale='zh_CN.utf8',             # 数据库字符集, 缺省值为utf8
+    sqlmode='oracle',                   # 数据库模式, 缺省值为oracle
+)
+
+user = "gbasedbt"                       # 数据库用户名
+password = "xxxxxx"                     # 数据库用户密码
+
+# 连接数据库
+conn = gbase8sdb.connect(dsn, user, password) 
+# 创建游标  
+cursor = conn.cursor()  
+# 执行SQL语句                       
+cursor.execute("drop table if exists t")
+cursor.execute("create table t (id int, name varchar(20))")
+cursor.execute("insert into t values (?, ?)", (1, "zhangsan"))  # sqlmode=mysql时使用%s作为占位符
+# 提交事务
+conn.commit()
+cursor.execute("select * from t")
+# 获取查询结果
+print(cursor.fetchall())
+# 关闭游标和连接
+cursor.close()
+conn.close()
+```
+
+
+

gbase8sdb-1.0.0/README.md

@@ -0,0 +1,57 @@
+# python-gbase8sdb
+
+python-gbase8sdb 是一个 [Python 编程语言][python] 扩展模块，允许 Python 程序连接到 GBase 8s 数据库。
+
+该模块符合 [Python 数据库 API 2.0 规范][pep249]，并且包含大量扩展和少数排除项。
+
+
+## 安装
+
+运行 `python -m pip install gbase8sdb` 安装。
+
+
+## 依赖和互操作性
+
+- 支持的 GBase 8s 数据库版本：GBase 8s V8.8_3.6.2版本及以上。
+
+- 支持的操作系统：Linux x86_64、 Linux AArch64、 Windows 64位操作系统 。
+
+
+#### 使用说明
+
+
+#### 入门
+在您的Python应用程序中，可以通过以下方式连接到数据库：
+```python
+import gbase8sdb
+
+# 生成数据库连接字符串
+dsn = gbase8sdb.makedsn(
+    db_name="testdbutf8",               # 数据库名称，如果不连库，设置为None
+    host="192.168.xxx.xxx",             # 数据库实例所在服务器的IP地址或域名，连接组时不需要提供此参数
+    port=9088,                          # 数据库实例的端口号，连接组时不需要提供此参数
+    db_locale='zh_CN.utf8',             # 数据库字符集, 缺省值为utf8
+    sqlmode='oracle',                   # 数据库模式, 缺省值为oracle
+)
+
+user = "gbasedbt"                       # 数据库用户名
+password = "xxxxxx"                     # 数据库用户密码
+
+# 连接数据库
+conn = gbase8sdb.connect(dsn, user, password) 
+# 创建游标  
+cursor = conn.cursor()  
+# 执行SQL语句                       
+cursor.execute("drop table if exists t")
+cursor.execute("create table t (id int, name varchar(20))")
+cursor.execute("insert into t values (?, ?)", (1, "zhangsan"))  # sqlmode=mysql时使用%s作为占位符
+# 提交事务
+conn.commit()
+cursor.execute("select * from t")
+# 获取查询结果
+print(cursor.fetchall())
+# 关闭游标和连接
+cursor.close()
+conn.close()
+```
+

gbase8sdb-1.0.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools >= 40.6.0", "wheel", "cython"]
+build-backend = "setuptools.build_meta"

gbase8sdb-1.0.0/setup.cfg

@@ -0,0 +1,26 @@
+[metadata]
+name = gbase8sdb
+description = Python interface to GBase 8s Database
+long_description = file: README.md
+long_description_content_type = text/markdown
+keywords = GBase 8s, database
+classifiers = 
+	Programming Language :: Python
+	Programming Language :: Python :: Implementation :: CPython
+	Programming Language :: Cython
+	Topic :: Database
+
+[options]
+zip_safe = false
+install_requires = six
+packages = find:
+package_dir = 
+	=src
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

gbase8sdb-1.0.0/setup.py

@@ -0,0 +1,40 @@
+
+import os
+import sys
+from setuptools import setup, Extension
+
+gdb_debug = False
+source_dir = "src/gbase8sdb"
+sys.path.append(source_dir)
+
+import version
+
+# driver
+driver_dir = os.path.join(source_dir, "impl")
+driver_depends = []
+for f in os.listdir(driver_dir):
+    if f.endswith((".pyx", "pxd", "pxi")):
+        driver_depends.append(os.path.join(driver_dir, f))
+driver_pxd = os.path.join(source_dir, "driver.pxd")
+driver_depends.append(driver_pxd)
+
+ext_modules = [
+    Extension(
+        "gbase8sdb.driver",
+        sources=[os.path.join(source_dir, "driver.pyx")],
+        depends=driver_depends,
+        extra_compile_args=["-std=c99", "-g0"],
+    ),
+]
+
+is_sdist = "sdist" in sys.argv
+if not is_sdist:
+    from Cython.Build import cythonize
+    ext_modules = cythonize(ext_modules, gdb_debug=gdb_debug)
+else:
+    ext_modules = ext_modules
+setup(
+        version=version.__version__,
+        ext_modules=ext_modules,
+)
+

gbase8sdb-1.0.0/src/gbase8sdb/__init__.py

@@ -0,0 +1,112 @@
+# coding: utf-8
+"""
+the package of gbase8sdb __init__ module
+"""
+
+import sys, os
+import collections
+
+apilevel = "2.0"
+paramstyle = "qmark"
+threadsafety = 2
+
+# version info
+from .version import __version__
+version = __version__
+
+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,
+    DB_TYPE_INTERVAL_DS,
+    DB_TYPE_INTERVAL_YM,
+    DB_TYPE_LONG_NVARCHAR,
+    DB_TYPE_LVARCHAR,
+    DB_TYPE_NCHAR,
+    DB_TYPE_NCLOB,
+    DB_TYPE_NUMBER,
+    DB_TYPE_NVARCHAR,
+    DB_TYPE_TIMESTAMP,
+    DB_TYPE_TIMESTAMP_TZ,
+    DB_TYPE_VARCHAR,
+    DB_TYPE_BYTE,
+    DB_TYPE_TEXT,
+    DB_TYPE_BOOLEAN,
+    DB_TYPE_LONG,
+    DB_TYPE_RAW,
+    DB_TYPE_JSON,
+    DB_TYPE_CLOB2,
+    # 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 .pool import create_pool
+
+if sys.version_info >= (3, 5):
+    from .connection_async import connect_async, AsyncConnection
+    from .cursor_async import AsyncCursor
+    from .lob_async import AsyncLOB
+    from .pool_async import create_pool_async
+
+from .column_metadata import ColumnMetaData
+
+from .var import Var
+
+from .dsn import makedsn
+
+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

gbase8sdb-1.0.0/src/gbase8sdb/column_metadata.py

@@ -0,0 +1,111 @@
+# coding: utf-8
+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(object):
+
+    __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 name(self):
+        return self._cyobj.name
+
+    @property
+    def precision(self):
+        if self._cyobj.precision or self._cyobj.scale:
+            return self._cyobj.precision
+
+    @property
+    def type(self):
+        if self._type is None:
+            self._type = self._cyobj.dbtype
+        return self._type
+
+    @property
+    def type_code(self):
+        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-1.0.0/src/gbase8sdb/connection.py

@@ -0,0 +1,192 @@
+# coding: utf-8
+import re, os, sys
+from . import __name__ as MODULE_NAME
+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, DB_TYPE_LONG
+
+locale_mapping = {
+            "zh_cn.57372": "utf8",
+            "zh_cn.utf8": "utf8",
+            "zh_cn.utf-8": "utf8",
+            "zh_cn.5488": "gb18030",
+            "zh_cn.gb18030": "gb18030",
+            "zh_cn.gb18030-2000": "gb18030",
+            "zh_cn.5510": "gb18030",
+            "zh_cn.gb18030-2022": "gb18030",
+            "en_us.819": "utf8",
+            "8859-1": "utf8",
+            "gb": "gbk",
+            "gb2312-80": "gbk",
+        }
+
+def get_client_locale(dsn_dict):
+    locale_8s = dsn_dict.get('CLIENT_LOCALE', 'zh_CN.utf8')
+    client_locale = locale_mapping.get(locale_8s.lower(), 'utf8')
+    if isinstance(client_locale, bytes):
+        client_locale = client_locale.decode()
+    return client_locale
+
+def _convert_dsn_to_dict(dsn):
+    p_dsn = re.compile(r'^gbase8s:(([\w]+)=(.*?);)+$')
+    match = p_dsn.findall(dsn)
+    if not match:
+        errors.raise_error(errors.ERR_INVALID_DSN)
+    kv = re.findall(r'([\w]+)=(.*?);', dsn[8:])
+    params_dict = dict(kv)
+    return params_dict
+
+
+class Connection(object):
+    __module__ = MODULE_NAME
+
+    def __init__(self, dsn, user, password):
+        self._cyobj = None
+        self._version = None
+        dsn_dict = _convert_dsn_to_dict(dsn)
+        self.sqlmode = dsn_dict.get("SQLMODE", "oracle")
+        if isinstance(dsn, bytes):
+            dsn = dsn.decode()
+        if isinstance(user, bytes):
+            user = user.decode()
+        if isinstance(password, bytes):
+            password = password.decode()
+        cy_conn = driver.CyConnection(dsn, user, password)
+        cy_conn.client_locale = get_client_locale(dsn_dict)
+        cy_conn.connect()
+        self._cyobj = cy_conn
+        self._client_locale = cy_conn.client_locale
+        
+    def __repr__(self):
+        if sys.version_info >= (3, 3):
+            cls_name = "{}.{}".format(self.__class__.__module__, self.__class__.__qualname__)
+        else:
+            cls_name = "{}.{}".format(self.__class__.__module__, self.__class__.__name__)
+        if self._cyobj is None:
+            return "<{} disconnected>".format(cls_name)
+        return "<{} to {}@{}>".format(cls_name, 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):
+        if self._cyobj is None:
+            errors.raise_error(errors.ERR_NOT_CONNECTED)   
+    
+    def close(self):
+        self._verify_connected()
+        self._cyobj.close()
+        self._cyobj = None
+
+    def commit(self):
+        self._verify_connected()
+        self._cyobj.commit()
+
+    def createlob(
+        self, lob_type, data = None
+    ):
+        self._verify_connected()
+        if lob_type not in (DB_TYPE_CLOB, DB_TYPE_NCLOB, DB_TYPE_BLOB, DB_TYPE_LONG):
+            message = (
+                "lob type should be one of gbase8sdb.DB_TYPE_BLOB, "
+                "gbase8sdb.DB_TYPE_CLOB, gbase8sdb.DB_TYPE_NCLOB or "
+                "gbase8sdb.DB_TYPE_LONG"
+            )
+            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, scrollable=False):
+        self._verify_connected()
+        return Cursor(self, scrollable)
+   
+    def ping(self):
+        self._verify_connected()
+        self._cyobj.ping()
+
+    def rollback(self):
+        self._verify_connected()
+        self._cyobj.rollback()       
+
+        
+    @property
+    def autocommit(self):
+        self._verify_connected()
+        return self._cyobj.autocommit
+
+    @autocommit.setter
+    def autocommit(self, value):
+        self._verify_connected()
+        self._cyobj.autocommit = value
+
+    @property
+    def dsn(self):
+        self._verify_connected()
+        return self._cyobj.dsn
+
+    @property
+    def inputtypehandler(self):
+        self._verify_connected()
+        return self._cyobj.inputtypehandler
+
+    @inputtypehandler.setter
+    def inputtypehandler(self, value):
+        self._verify_connected()
+        self._cyobj.inputtypehandler = value
+
+
+    @property
+    def outputtypehandler(self):
+        self._verify_connected()
+        return self._cyobj.outputtypehandler
+
+    @outputtypehandler.setter
+    def outputtypehandler(self, value):
+        self._verify_connected()
+        self._cyobj.outputtypehandler = value
+
+    @property
+    def transaction_in_progress(self):
+        self._verify_connected()
+        return self._cyobj.get_transaction_in_progress()
+
+    @property
+    def username(self):
+        self._verify_connected()
+        return self._cyobj.username
+
+    @property
+    def version(self):
+        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 client_locale(self):
+        return self._client_locale
+
+
+def connect(dsn, user, password):
+    """
+    创建数据库连接，并返回连接对象
+    """
+    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)