sqlalchemy-pytibero 0.1.0__tar.gz

sqlalchemy_pytibero-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yeongseon Choe
+
+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.

sqlalchemy_pytibero-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: sqlalchemy-pytibero
+Version: 0.1.0
+Summary: Tibero dialect for SQLAlchemy
+Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yeongseon/sqlalchemy-pytibero
+Project-URL: Repository, https://github.com/yeongseon/sqlalchemy-pytibero
+Project-URL: Issues, https://github.com/yeongseon/sqlalchemy-pytibero/issues
+Keywords: SQLAlchemy,Tibero,dialect
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: SQL
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy<2.2,>=2.0
+Provides-Extra: pytibero
+Requires-Dist: pytibero; extra == "pytibero"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff==0.15.6; extra == "dev"
+Dynamic: license-file
+
+# sqlalchemy-pytibero
+
+[![PyPI version](https://img.shields.io/pypi/v/sqlalchemy-pytibero)](https://pypi.org/project/sqlalchemy-pytibero)
+[![CI](https://github.com/yeongseon/sqlalchemy-pytibero/actions/workflows/ci.yml/badge.svg)](https://github.com/yeongseon/sqlalchemy-pytibero/actions/workflows/ci.yml)
+[![license](https://img.shields.io/github/license/yeongseon/sqlalchemy-pytibero)](https://github.com/yeongseon/sqlalchemy-pytibero/blob/main/LICENSE)
+
+SQLAlchemy 2.0 dialect for the Tibero database, backed by `pytibero`.
+
+## Installation
+
+```bash
+pip install sqlalchemy-pytibero
+```
+
+With DB-API dependency:
+
+```bash
+pip install "sqlalchemy-pytibero[pytibero]"
+```
+
+## Quick Start
+
+```python
+from sqlalchemy import create_engine, text
+
+engine = create_engine("tibero://tibero:password@localhost:8629/TESTDB")
+
+with engine.connect() as conn:
+    value = conn.execute(text("SELECT 1 FROM DUAL")).scalar()
+    print(value)
+```
+
+## Architecture
+
+```mermaid
+flowchart TD
+    app["Application"] --> sa["SQLAlchemy Core/ORM"]
+    sa --> dialect["TiberoDialect"]
+    dialect --> dbapi["pytibero"]
+    dbapi --> server["Tibero Server"]
+```
+
+## Development
+
+```bash
+make lint
+make test
+```
+
+## License
+
+MIT

sqlalchemy_pytibero-0.1.0/README.md

@@ -0,0 +1,52 @@
+# sqlalchemy-pytibero
+
+[![PyPI version](https://img.shields.io/pypi/v/sqlalchemy-pytibero)](https://pypi.org/project/sqlalchemy-pytibero)
+[![CI](https://github.com/yeongseon/sqlalchemy-pytibero/actions/workflows/ci.yml/badge.svg)](https://github.com/yeongseon/sqlalchemy-pytibero/actions/workflows/ci.yml)
+[![license](https://img.shields.io/github/license/yeongseon/sqlalchemy-pytibero)](https://github.com/yeongseon/sqlalchemy-pytibero/blob/main/LICENSE)
+
+SQLAlchemy 2.0 dialect for the Tibero database, backed by `pytibero`.
+
+## Installation
+
+```bash
+pip install sqlalchemy-pytibero
+```
+
+With DB-API dependency:
+
+```bash
+pip install "sqlalchemy-pytibero[pytibero]"
+```
+
+## Quick Start
+
+```python
+from sqlalchemy import create_engine, text
+
+engine = create_engine("tibero://tibero:password@localhost:8629/TESTDB")
+
+with engine.connect() as conn:
+    value = conn.execute(text("SELECT 1 FROM DUAL")).scalar()
+    print(value)
+```
+
+## Architecture
+
+```mermaid
+flowchart TD
+    app["Application"] --> sa["SQLAlchemy Core/ORM"]
+    sa --> dialect["TiberoDialect"]
+    dialect --> dbapi["pytibero"]
+    dbapi --> server["Tibero Server"]
+```
+
+## Development
+
+```bash
+make lint
+make test
+```
+
+## License
+
+MIT

sqlalchemy_pytibero-0.1.0/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["setuptools>=65.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqlalchemy-pytibero"
+version = "0.1.0"
+description = "Tibero dialect for SQLAlchemy"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "Yeongseon Choe", email = "yeongseon.choe@gmail.com"},
+]
+keywords = ["SQLAlchemy", "Tibero", "dialect"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: SQL",
+    "Topic :: Database",
+    "Topic :: Database :: Front-Ends",
+]
+dependencies = [
+    "sqlalchemy>=2.0,<2.2",
+]
+
+[project.optional-dependencies]
+pytibero = ["pytibero"]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "ruff==0.15.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/yeongseon/sqlalchemy-pytibero"
+Repository = "https://github.com/yeongseon/sqlalchemy-pytibero"
+Issues = "https://github.com/yeongseon/sqlalchemy-pytibero/issues"
+
+[project.entry-points."sqlalchemy.dialects"]
+tibero = "sqlalchemy_pytibero.dialect:TiberoDialect"
+"tibero.pytibero" = "sqlalchemy_pytibero.dialect:TiberoDialect"
+
+[tool.setuptools]
+packages = ["sqlalchemy_pytibero"]
+include-package-data = true
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint.isort]
+known-first-party = ["sqlalchemy_pytibero"]
+
+[tool.coverage.run]
+source = ["sqlalchemy_pytibero"]
+
+[tool.coverage.report]
+show_missing = true
+fail_under = 95
+
+[tool.pytest.ini_options]
+testpaths = ["test"]
+addopts = "--tb native -v -r fxX --maxfail=25 -p no:warnings"
+python_files = "test/*test_*.py"
+
+[tool.basedpyright]
+typeCheckingMode = "off"
+reportUnsafeMultipleInheritance = "none"
+reportMissingTypeArgument = "none"
+reportIncompatibleMethodOverride = "none"
+reportAssignmentType = "none"

sqlalchemy_pytibero-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlalchemy_pytibero-0.1.0/sqlalchemy_pytibero/__init__.py

@@ -0,0 +1,58 @@
+from .dialect import TiberoDialect
+from .types import (
+    BIGINT,
+    BINARY_DOUBLE,
+    BINARY_FLOAT,
+    BLOB,
+    CHAR,
+    CLOB,
+    DATE,
+    DECIMAL,
+    FLOAT,
+    INTEGER,
+    INTERVAL_DAY_TO_SECOND,
+    INTERVAL_YEAR_TO_MONTH,
+    LONG,
+    LONG_RAW,
+    NCHAR,
+    NCLOB,
+    NUMBER,
+    NUMERIC,
+    NVARCHAR2,
+    RAW,
+    ROWID,
+    SMALLINT,
+    TIMESTAMP,
+    VARCHAR2,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "TiberoDialect",
+    "NUMBER",
+    "NUMERIC",
+    "DECIMAL",
+    "FLOAT",
+    "BINARY_FLOAT",
+    "BINARY_DOUBLE",
+    "SMALLINT",
+    "INTEGER",
+    "BIGINT",
+    "VARCHAR2",
+    "CHAR",
+    "NCHAR",
+    "NVARCHAR2",
+    "CLOB",
+    "BLOB",
+    "NCLOB",
+    "DATE",
+    "TIMESTAMP",
+    "INTERVAL_YEAR_TO_MONTH",
+    "INTERVAL_DAY_TO_SECOND",
+    "RAW",
+    "LONG_RAW",
+    "LONG",
+    "ROWID",
+]

sqlalchemy_pytibero-0.1.0/sqlalchemy_pytibero/base.py

@@ -0,0 +1,155 @@
+# pyright: reportIncompatibleMethodOverride=false
+from __future__ import annotations
+
+import re
+
+from sqlalchemy.engine import default
+from sqlalchemy.sql import compiler
+
+
+AUTOCOMMIT_REGEXP = re.compile(
+    r"\s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER|MERGE|TRUNCATE)", re.I | re.UNICODE
+)
+
+RESERVED_WORDS = frozenset(
+    {
+        "access",
+        "add",
+        "all",
+        "alter",
+        "and",
+        "any",
+        "as",
+        "asc",
+        "audit",
+        "between",
+        "by",
+        "char",
+        "check",
+        "cluster",
+        "column",
+        "comment",
+        "compress",
+        "connect",
+        "create",
+        "current",
+        "date",
+        "decimal",
+        "default",
+        "delete",
+        "desc",
+        "distinct",
+        "drop",
+        "else",
+        "exclusive",
+        "exists",
+        "file",
+        "float",
+        "for",
+        "from",
+        "grant",
+        "group",
+        "having",
+        "identified",
+        "if",
+        "immediate",
+        "in",
+        "increment",
+        "index",
+        "initial",
+        "insert",
+        "integer",
+        "intersect",
+        "into",
+        "is",
+        "level",
+        "like",
+        "lock",
+        "long",
+        "maxextents",
+        "minus",
+        "mlslabel",
+        "mode",
+        "modify",
+        "noaudit",
+        "nocompress",
+        "not",
+        "nowait",
+        "null",
+        "number",
+        "of",
+        "offline",
+        "on",
+        "online",
+        "option",
+        "or",
+        "order",
+        "pctfree",
+        "prior",
+        "privileges",
+        "public",
+        "raw",
+        "rename",
+        "resource",
+        "revoke",
+        "row",
+        "rowid",
+        "rownum",
+        "rows",
+        "select",
+        "session",
+        "set",
+        "share",
+        "size",
+        "smallint",
+        "start",
+        "successful",
+        "synonym",
+        "sysdate",
+        "table",
+        "then",
+        "to",
+        "trigger",
+        "uid",
+        "union",
+        "unique",
+        "update",
+        "user",
+        "validate",
+        "values",
+        "varchar",
+        "varchar2",
+        "view",
+        "whenever",
+        "where",
+        "with",
+    }
+)
+
+
+class TiberoIdentifierPreparer(compiler.IdentifierPreparer):
+    reserved_words = RESERVED_WORDS
+
+    def __init__(
+        self,
+        dialect,
+        initial_quote='"',
+        final_quote=None,
+        escape_quote='"',
+        omit_schema=False,
+    ):
+        super().__init__(dialect, initial_quote, final_quote, escape_quote, omit_schema)
+
+    def _quote_free_identifiers(self, *ids):
+        return tuple(self.quote_identifier(i) for i in ids if i is not None)
+
+
+class TiberoExecutionContext(default.DefaultExecutionContext):
+    def should_autocommit_text(self, statement):
+        return AUTOCOMMIT_REGEXP.match(statement)
+
+    def get_lastrowid(self):
+        try:
+            return self.cursor.lastrowid
+        except Exception:
+            return None

sqlalchemy_pytibero-0.1.0/sqlalchemy_pytibero/compiler.py

@@ -0,0 +1,236 @@
+# pyright: reportIncompatibleMethodOverride=false, reportArgumentType=false
+from __future__ import annotations
+
+from sqlalchemy.sql import compiler
+from sqlalchemy.sql import sqltypes
+
+
+class TiberoCompiler(compiler.SQLCompiler):
+    def visit_sysdate_func(self, fn, **kw):
+        return "SYSDATE"
+
+    def visit_systimestamp_func(self, fn, **kw):
+        return "SYSTIMESTAMP"
+
+    def visit_dual_func(self, fn, **kw):
+        return "DUAL"
+
+    def visit_nvl_func(self, fn, **kw):
+        return "NVL(%s)" % self.function_argspec(fn, **kw)
+
+    def default_from(self):
+        return " FROM DUAL"
+
+    def visit_cast(self, cast, **kw):
+        type_ = self.process(cast.typeclause)
+        if type_ is None:
+            return self.process(cast.clause.self_group())
+        return f"CAST({self.process(cast.clause)} AS {type_})"
+
+    def render_literal_value(self, value, type_):
+        value = super().render_literal_value(value, type_)
+        return value.replace("\\", "\\\\")
+
+    def get_select_precolumns(self, select, **kw):
+        if bool(select._distinct):
+            return "DISTINCT "
+        return ""
+
+    def visit_join(self, join, asfrom=False, **kwargs):
+        return "".join(
+            (
+                self.process(join.left, asfrom=True, **kwargs),
+                (join.isouter and " LEFT OUTER JOIN " or " INNER JOIN "),
+                self.process(join.right, asfrom=True, **kwargs),
+                " ON ",
+                self.process(join.onclause, **kwargs),
+            )
+        )
+
+    def for_update_clause(self, select, **kw):
+        if select._for_update_arg is None:
+            return ""
+        text = " FOR UPDATE"
+        if select._for_update_arg.of:
+            text += " OF " + ", ".join(self.process(col, **kw) for col in select._for_update_arg.of)
+        if select._for_update_arg.nowait:
+            text += " NOWAIT"
+        return text
+
+    def limit_clause(self, select, **kw):
+        limit_clause = select._limit_clause
+        offset_clause = select._offset_clause
+        if limit_clause is None and offset_clause is None:
+            return ""
+        if limit_clause is None and offset_clause is not None:
+            return "\n OFFSET %s ROWS" % self.process(offset_clause, **kw)
+        if offset_clause is not None:
+            return "\n OFFSET %s ROWS FETCH FIRST %s ROWS ONLY" % (
+                self.process(offset_clause, **kw),
+                self.process(limit_clause, **kw),
+            )
+        return "\n FETCH FIRST %s ROWS ONLY" % self.process(limit_clause, **kw)
+
+
+class TiberoDDLCompiler(compiler.DDLCompiler):
+    def get_column_specification(self, column, **kw):
+        colspec = [
+            self.preparer.format_column(column),
+            self.dialect.type_compiler_instance.process(column.type, type_expression=column),
+        ]
+
+        if not column.nullable:
+            colspec.append("NOT NULL")
+
+        if (
+            column.table is not None
+            and column is column.table._autoincrement_column
+            and column.server_default is None
+        ):
+            colspec.append("GENERATED ALWAYS AS IDENTITY")
+        else:
+            default = self.get_column_default_string(column)
+            if default is not None:
+                colspec.append("DEFAULT " + default)
+
+        return " ".join(colspec)
+
+    def post_create_table(self, table):
+        if table.comment is None:
+            return ""
+        literal = self.sql_compiler.render_literal_value(table.comment, sqltypes.String())
+        return f"\nCOMMENT ON TABLE {self.preparer.format_table(table)} IS {literal}"
+
+    def visit_set_table_comment(self, create, **kw):
+        return "COMMENT ON TABLE %s IS %s" % (
+            self.preparer.format_table(create.element),
+            self.sql_compiler.render_literal_value(create.element.comment, sqltypes.String()),
+        )
+
+    def visit_drop_table_comment(self, drop, **kw):
+        return "COMMENT ON TABLE %s IS ''" % (self.preparer.format_table(drop.element),)
+
+    def visit_set_column_comment(self, create, **kw):
+        return "COMMENT ON COLUMN %s.%s IS %s" % (
+            self.preparer.format_table(create.element.table),
+            self.preparer.format_column(create.element),
+            self.sql_compiler.render_literal_value(create.element.comment, sqltypes.String()),
+        )
+
+
+class TiberoTypeCompiler(compiler.GenericTypeCompiler):
+    def visit_BOOLEAN(self, type_, **kw):
+        return "NUMBER(1)"
+
+    def visit_NUMERIC(self, type_, **kw):
+        if type_.precision is None:
+            return "NUMERIC"
+        if type_.scale is None:
+            return f"NUMERIC({type_.precision})"
+        return f"NUMERIC({type_.precision}, {type_.scale})"
+
+    def visit_NUMBER(self, type_, **kw):
+        if type_.precision is None:
+            return "NUMBER"
+        if type_.scale is None:
+            return f"NUMBER({type_.precision})"
+        return f"NUMBER({type_.precision}, {type_.scale})"
+
+    def visit_DECIMAL(self, type_, **kw):
+        if type_.precision is None:
+            return "DECIMAL"
+        if type_.scale is None:
+            return f"DECIMAL({type_.precision})"
+        return f"DECIMAL({type_.precision}, {type_.scale})"
+
+    def visit_FLOAT(self, type_, **kw):
+        if type_.precision is None:
+            return "FLOAT"
+        return f"FLOAT({type_.precision})"
+
+    def visit_BINARY_FLOAT(self, type_, **kw):
+        return "BINARY_FLOAT"
+
+    def visit_BINARY_DOUBLE(self, type_, **kw):
+        return "BINARY_DOUBLE"
+
+    def visit_SMALLINT(self, type_, **kw):
+        return "SMALLINT"
+
+    def visit_INTEGER(self, type_, **kw):
+        return "INTEGER"
+
+    def visit_BIGINT(self, type_, **kw):
+        return "NUMBER(19)"
+
+    def visit_VARCHAR(self, type_, **kw):
+        return self.visit_VARCHAR2(type_, **kw)
+
+    def visit_VARCHAR2(self, type_, **kw):
+        if type_.length:
+            return f"VARCHAR2({type_.length})"
+        return "VARCHAR2"
+
+    def visit_CHAR(self, type_, **kw):
+        if getattr(type_, "national", False):
+            return self.visit_NCHAR(type_, **kw)
+        if type_.length:
+            return f"CHAR({type_.length})"
+        return "CHAR"
+
+    def visit_NCHAR(self, type_, **kw):
+        if type_.length:
+            return f"NCHAR({type_.length})"
+        return "NCHAR"
+
+    def visit_NVARCHAR(self, type_, **kw):
+        return self.visit_NVARCHAR2(type_, **kw)
+
+    def visit_NVARCHAR2(self, type_, **kw):
+        if type_.length:
+            return f"NVARCHAR2({type_.length})"
+        return "NVARCHAR2"
+
+    def visit_CLOB(self, type_, **kw):
+        return "CLOB"
+
+    def visit_NCLOB(self, type_, **kw):
+        return "NCLOB"
+
+    def visit_BLOB(self, type_, **kw):
+        return "BLOB"
+
+    def visit_RAW(self, type_, **kw):
+        if getattr(type_, "length", None):
+            return f"RAW({type_.length})"
+        return "RAW"
+
+    def visit_LONG(self, type_, **kw):
+        return "LONG"
+
+    def visit_LONG_RAW(self, type_, **kw):
+        return "LONG RAW"
+
+    def visit_ROWID(self, type_, **kw):
+        return "ROWID"
+
+    def visit_DATE(self, type_, **kw):
+        return "DATE"
+
+    def visit_TIMESTAMP(self, type_, **kw):
+        return "TIMESTAMP"
+
+    def visit_INTERVAL_YEAR_TO_MONTH(self, type_, **kw):
+        return "INTERVAL YEAR TO MONTH"
+
+    def visit_INTERVAL_DAY_TO_SECOND(self, type_, **kw):
+        return "INTERVAL DAY TO SECOND"
+
+    def visit_large_binary(self, type_, **kw):
+        return "BLOB"
+
+    def visit_text(self, type_, **kw):
+        return "CLOB"
+
+    def visit_datetime(self, type_, **kw):
+        return "DATE"