sqlalchemy-pyaltibase 0.1.0__tar.gz

sqlalchemy_pyaltibase-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_pyaltibase-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: sqlalchemy-pyaltibase
+Version: 0.1.0
+Summary: Altibase dialect for SQLAlchemy
+Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yeongseon/sqlalchemy-pyaltibase
+Project-URL: Repository, https://github.com/yeongseon/sqlalchemy-pyaltibase
+Project-URL: Issues, https://github.com/yeongseon/sqlalchemy-pyaltibase/issues
+Keywords: SQLAlchemy,Altibase,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: pyaltibase
+Requires-Dist: pyaltibase; extra == "pyaltibase"
+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-pyaltibase
+
+[![PyPI version](https://img.shields.io/pypi/v/sqlalchemy-pyaltibase)](https://pypi.org/project/sqlalchemy-pyaltibase)
+[![CI](https://github.com/yeongseon/sqlalchemy-pyaltibase/actions/workflows/ci.yml/badge.svg)](https://github.com/yeongseon/sqlalchemy-pyaltibase/actions/workflows/ci.yml)
+[![license](https://img.shields.io/github/license/yeongseon/sqlalchemy-pyaltibase)](https://github.com/yeongseon/sqlalchemy-pyaltibase/blob/main/LICENSE)
+
+SQLAlchemy 2.0 dialect for the Altibase database, backed by `pyaltibase`.
+
+## Installation
+
+```bash
+pip install sqlalchemy-pyaltibase
+```
+
+With DB-API dependency:
+
+```bash
+pip install "sqlalchemy-pyaltibase[pyaltibase]"
+```
+
+## Quick Start
+
+```python
+from sqlalchemy import create_engine, text
+
+engine = create_engine("altibase://user:password@localhost:20300/mydb")
+
+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["AltibaseDialect"]
+    dialect --> dbapi["pyaltibase"]
+    dbapi --> server["Altibase Server"]
+```
+
+## Development
+
+```bash
+make lint
+make test
+```
+
+## License
+
+MIT

sqlalchemy_pyaltibase-0.1.0/README.md

@@ -0,0 +1,52 @@
+# sqlalchemy-pyaltibase
+
+[![PyPI version](https://img.shields.io/pypi/v/sqlalchemy-pyaltibase)](https://pypi.org/project/sqlalchemy-pyaltibase)
+[![CI](https://github.com/yeongseon/sqlalchemy-pyaltibase/actions/workflows/ci.yml/badge.svg)](https://github.com/yeongseon/sqlalchemy-pyaltibase/actions/workflows/ci.yml)
+[![license](https://img.shields.io/github/license/yeongseon/sqlalchemy-pyaltibase)](https://github.com/yeongseon/sqlalchemy-pyaltibase/blob/main/LICENSE)
+
+SQLAlchemy 2.0 dialect for the Altibase database, backed by `pyaltibase`.
+
+## Installation
+
+```bash
+pip install sqlalchemy-pyaltibase
+```
+
+With DB-API dependency:
+
+```bash
+pip install "sqlalchemy-pyaltibase[pyaltibase]"
+```
+
+## Quick Start
+
+```python
+from sqlalchemy import create_engine, text
+
+engine = create_engine("altibase://user:password@localhost:20300/mydb")
+
+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["AltibaseDialect"]
+    dialect --> dbapi["pyaltibase"]
+    dbapi --> server["Altibase Server"]
+```
+
+## Development
+
+```bash
+make lint
+make test
+```
+
+## License
+
+MIT

sqlalchemy_pyaltibase-0.1.0/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["setuptools>=65.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqlalchemy-pyaltibase"
+version = "0.1.0"
+description = "Altibase dialect for SQLAlchemy"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "Yeongseon Choe", email = "yeongseon.choe@gmail.com"},
+]
+keywords = ["SQLAlchemy", "Altibase", "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]
+pyaltibase = ["pyaltibase"]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "ruff==0.15.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/yeongseon/sqlalchemy-pyaltibase"
+Repository = "https://github.com/yeongseon/sqlalchemy-pyaltibase"
+Issues = "https://github.com/yeongseon/sqlalchemy-pyaltibase/issues"
+
+[project.entry-points."sqlalchemy.dialects"]
+altibase = "sqlalchemy_altibase.dialect:AltibaseDialect"
+"altibase.pyaltibase" = "sqlalchemy_altibase.dialect:AltibaseDialect"
+
+[tool.setuptools]
+packages = ["sqlalchemy_altibase"]
+include-package-data = true
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint.isort]
+known-first-party = ["sqlalchemy_altibase"]
+
+[tool.coverage.run]
+source = ["sqlalchemy_altibase"]
+
+[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_pyaltibase-0.1.0/setup.cfg

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

sqlalchemy_pyaltibase-0.1.0/sqlalchemy_altibase/__init__.py

@@ -0,0 +1,54 @@
+from .dialect import AltibaseDialect
+from .types import (
+    BIGINT,
+    BIT,
+    BLOB,
+    BYTE,
+    CHAR,
+    CLOB,
+    DATE,
+    DECIMAL,
+    DOUBLE,
+    FLOAT,
+    GEOMETRY,
+    INTEGER,
+    NCHAR,
+    NIBBLE,
+    NUMERIC,
+    NVARCHAR,
+    REAL,
+    SERIAL,
+    SMALLINT,
+    VARBIT,
+    VARBYTE,
+    VARCHAR,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "AltibaseDialect",
+    "NUMERIC",
+    "DECIMAL",
+    "FLOAT",
+    "REAL",
+    "DOUBLE",
+    "SMALLINT",
+    "INTEGER",
+    "BIGINT",
+    "SERIAL",
+    "VARCHAR",
+    "CHAR",
+    "NCHAR",
+    "NVARCHAR",
+    "CLOB",
+    "BLOB",
+    "DATE",
+    "BIT",
+    "VARBIT",
+    "BYTE",
+    "VARBYTE",
+    "NIBBLE",
+    "GEOMETRY",
+]

sqlalchemy_pyaltibase-0.1.0/sqlalchemy_altibase/base.py

@@ -0,0 +1,154 @@
+# 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",
+        "at",
+        "between",
+        "by",
+        "cascade",
+        "case",
+        "check",
+        "column",
+        "connect",
+        "constraint",
+        "create",
+        "cross",
+        "current",
+        "cursor",
+        "database",
+        "date",
+        "decimal",
+        "default",
+        "delete",
+        "desc",
+        "distinct",
+        "drop",
+        "each",
+        "else",
+        "end",
+        "escape",
+        "exception",
+        "exec",
+        "exists",
+        "float",
+        "for",
+        "foreign",
+        "from",
+        "full",
+        "grant",
+        "group",
+        "having",
+        "if",
+        "in",
+        "index",
+        "inner",
+        "insert",
+        "integer",
+        "intersect",
+        "into",
+        "is",
+        "join",
+        "key",
+        "left",
+        "level",
+        "like",
+        "limit",
+        "lock",
+        "merge",
+        "minus",
+        "modify",
+        "not",
+        "null",
+        "number",
+        "of",
+        "on",
+        "open",
+        "or",
+        "order",
+        "outer",
+        "primary",
+        "prior",
+        "privileges",
+        "public",
+        "raw",
+        "references",
+        "rename",
+        "replace",
+        "return",
+        "revoke",
+        "right",
+        "row",
+        "rowcount",
+        "rownum",
+        "rows",
+        "select",
+        "sequence",
+        "session",
+        "set",
+        "some",
+        "start",
+        "step",
+        "table",
+        "then",
+        "to",
+        "trigger",
+        "truncate",
+        "union",
+        "unique",
+        "update",
+        "user",
+        "using",
+        "values",
+        "varchar",
+        "view",
+        "when",
+        "where",
+        "with",
+    }
+)
+
+
+class AltibaseIdentifierPreparer(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 AltibaseExecutionContext(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_pyaltibase-0.1.0/sqlalchemy_altibase/compiler.py

@@ -0,0 +1,226 @@
+# pyright: reportIncompatibleMethodOverride=false, reportArgumentType=false, reportUnusedParameter=false
+from __future__ import annotations
+
+from sqlalchemy.sql import compiler
+from sqlalchemy.sql import sqltypes
+
+
+class AltibaseCompiler(compiler.SQLCompiler):
+    def visit_sysdate_func(self, fn, **kw):
+        return "SYSDATE"
+
+    def visit_dual_func(self, fn, **kw):
+        return "DUAL"
+
+    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)
+        wait = getattr(select._for_update_arg, "wait", None)
+        if wait is not None:
+            text += f" WAIT {int(wait)}"
+        elif 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:
+            return "\n LIMIT 9223372036854775807 OFFSET %s" % self.process(offset_clause, **kw)
+        if offset_clause is None:
+            return "\n LIMIT %s" % self.process(limit_clause, **kw)
+        return "\n LIMIT %s OFFSET %s" % (
+            self.process(limit_clause, **kw),
+            self.process(offset_clause, **kw),
+        )
+
+
+class AltibaseDDLCompiler(compiler.DDLCompiler):
+    def get_column_specification(self, column, **kw):
+        colspec = [self.preparer.format_column(column)]
+
+        if (
+            column.table is not None
+            and column is column.table._autoincrement_column
+            and column.server_default is None
+        ):
+            colspec.append("SERIAL")
+        else:
+            colspec.append(
+                self.dialect.type_compiler_instance.process(column.type, type_expression=column)
+            )
+
+        if not column.nullable:
+            colspec.append("NOT NULL")
+
+        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 AltibaseTypeCompiler(compiler.GenericTypeCompiler):
+    def visit_BOOLEAN(self, type_, **kw):
+        return "SMALLINT"
+
+    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_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_REAL(self, type_, **kw):
+        return "REAL"
+
+    def visit_DOUBLE(self, type_, **kw):
+        return "DOUBLE"
+
+    def visit_SMALLINT(self, type_, **kw):
+        return "SMALLINT"
+
+    def visit_INTEGER(self, type_, **kw):
+        return "INTEGER"
+
+    def visit_BIGINT(self, type_, **kw):
+        return "BIGINT"
+
+    def visit_SERIAL(self, type_, **kw):
+        return "SERIAL"
+
+    def visit_VARCHAR(self, type_, **kw):
+        if type_.length:
+            return f"VARCHAR({type_.length})"
+        return "VARCHAR"
+
+    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):
+        if type_.length:
+            return f"NVARCHAR({type_.length})"
+        return "NVARCHAR"
+
+    def visit_CLOB(self, type_, **kw):
+        return "CLOB"
+
+    def visit_BLOB(self, type_, **kw):
+        return "BLOB"
+
+    def visit_BIT(self, type_, **kw):
+        if getattr(type_, "length", None):
+            return f"BIT({type_.length})"
+        return "BIT"
+
+    def visit_VARBIT(self, type_, **kw):
+        if getattr(type_, "length", None):
+            return f"VARBIT({type_.length})"
+        return "VARBIT"
+
+    def visit_BYTE(self, type_, **kw):
+        if getattr(type_, "length", None):
+            return f"BYTE({type_.length})"
+        return "BYTE"
+
+    def visit_VARBYTE(self, type_, **kw):
+        if getattr(type_, "length", None):
+            return f"VARBYTE({type_.length})"
+        return "VARBYTE"
+
+    def visit_NIBBLE(self, type_, **kw):
+        if getattr(type_, "length", None):
+            return f"NIBBLE({type_.length})"
+        return "NIBBLE"
+
+    def visit_GEOMETRY(self, type_, **kw):
+        return "GEOMETRY"
+
+    def visit_DATE(self, type_, **kw):
+        return "DATE"
+
+    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"