sqlalchemy-firebirdsql 0.1.0__tar.gz

sqlalchemy_firebirdsql-0.1.0/AUTHORS

@@ -0,0 +1,30 @@
+SQLAlchemy was created by Michael Bayer.
+
+Major contributing authors include:
+
+- Mike Bayer
+- Jason Kirtland
+- Michael Trier
+- Diana Clarke
+- Gaetan de Menten
+- Lele Gaifax
+- Jonathan Ellis
+- Gord Thompson
+- Federico Caselli
+- Philip Jenvey
+- Rick Morrison
+- Chris Withers
+- Ants Aasma
+- Sheila Allen
+- Paul Johnston
+- Tony Locke
+- Hajime Nakagami
+- Vraj Mohan
+- Robert Leftwich
+- Taavi Burns
+- Jonathan Vanasco
+- Jeff Widman
+- Scott Dugas
+- Dobes Vandermeer
+- Ville Skytta
+- Rodrigo Menezes

sqlalchemy_firebirdsql-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2005-2026 SQLAlchemy authors and contributors <see AUTHORS file>.
+
+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_firebirdsql-0.1.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: sqlalchemy_firebirdsql
+Version: 0.1.0
+Summary: Firebird for SQLAlchemy
+Author: F.D.Castel
+Author-email: Paul Graves-DesLauriers <paul@dexmicro.com>, Hajime Nakagami <nakagami@gmail.com>
+Maintainer-email: Hajime Nakagami <nakagami@gmail.com>
+License: Copyright 2005-2026 SQLAlchemy authors and contributors <see AUTHORS file>.
+        
+        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.
+        
+Keywords: SQLAlchemy,Firebird,firebirdsql
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: firebirdsql
+Dynamic: license-file
+
+============================
+sqlalchemy-firebirdsql
+============================
+
+`SQLAlchemy <https://www.sqlalchemy.org/>`_ dialect
+for `Firebird <https://firebirdsql.org/en/start/>`_
+using `pyfirebirdsql <https://github.com/nakagami/pyfirebirdsql>`_ .
+
+It based on `sqlalchemy-firebird <https://github.com/pauldex/sqlalchemy-firebird>`_ , thanks.
+
+Requirements
+++++++++++++++++
+
+It is difficult to support many versions, so I target newer versions.
+
+- Firebird 4.0+
+- SQLAlchemy 2.0+
+- Python 3.10+
+
+Installation
+++++++++++++++++
+
+::
+
+   pip install sqlalchemy_firebirdsql
+
+Connection strings
++++++++++++++++++++
+
+A SQLAlchemy URL has the shape ``dialect+driver://username:password@host:port/database``.
+For this dialect:
+
+::
+
+   firebirdsql+syn://user:password@host:port/path/to/db[?key=value&key=value...]
+
+For async:
+
+::
+
+   firebirdsql+asyn://user:password@host:port/path/to/db[?key=value&key=value...]
+
+The bare ``firebirdsql://`` scheme defaults to the synchronous (``syn``) driver.
+
+Examples
+--------
+
+Local server, default port::
+
+   firebirdsql+syn://sysdba:masterkey@localhost//home/me/databases/my_project.fdb
+
+Remote server on port 3050::
+
+   firebirdsql+syn://sysdba:masterkey@example.com:3050//srv/databases/my_project.fdb
+
+Usage
+++++++++++++++++
+
+Synchronous
+-----------
+
+.. code-block:: python
+
+   from sqlalchemy import create_engine, text
+
+   engine = create_engine(
+       "firebirdsql+syn://sysdba:masterkey@localhost//home/me/databases/my_project.fdb",
+       echo=True,
+   )
+
+   with engine.connect() as conn:
+       result = conn.execute(text("select 1 from rdb$database"))
+       print(result.scalar())
+
+Asynchronous
+------------
+
+.. code-block:: python
+
+   import asyncio
+   from sqlalchemy import text
+   from sqlalchemy.ext.asyncio import create_async_engine
+
+   engine = create_async_engine(
+       "firebirdsql+asyn://sysdba:masterkey@localhost//home/me/databases/my_project.fdb",
+       echo=True,
+   )
+
+   async def main():
+       async with engine.connect() as conn:
+           result = await conn.execute(text("select 1 from rdb$database"))
+           print(result.scalar())
+
+   asyncio.run(main())
+
+How to test
+++++++++++++++++
+
+Clone and install
+--------------------
+
+::
+
+   git clone git@github.com:nakagami/sqlalchemy_firebirdsql.git
+   cd sqlalchemy_firebirdsql
+   python3 -m venv .venv
+   . .venv/bin/activate
+   pip install -e .
+   pip install pytest
+
+Create test database and execute pytest
+-------------------------------------------
+
+::
+
+   prepare-test-environment
+   pytest --db syn
+   pytest --db asyn
+

sqlalchemy_firebirdsql-0.1.0/README.rst

@@ -0,0 +1,119 @@
+============================
+sqlalchemy-firebirdsql
+============================
+
+`SQLAlchemy <https://www.sqlalchemy.org/>`_ dialect
+for `Firebird <https://firebirdsql.org/en/start/>`_
+using `pyfirebirdsql <https://github.com/nakagami/pyfirebirdsql>`_ .
+
+It based on `sqlalchemy-firebird <https://github.com/pauldex/sqlalchemy-firebird>`_ , thanks.
+
+Requirements
+++++++++++++++++
+
+It is difficult to support many versions, so I target newer versions.
+
+- Firebird 4.0+
+- SQLAlchemy 2.0+
+- Python 3.10+
+
+Installation
+++++++++++++++++
+
+::
+
+   pip install sqlalchemy_firebirdsql
+
+Connection strings
++++++++++++++++++++
+
+A SQLAlchemy URL has the shape ``dialect+driver://username:password@host:port/database``.
+For this dialect:
+
+::
+
+   firebirdsql+syn://user:password@host:port/path/to/db[?key=value&key=value...]
+
+For async:
+
+::
+
+   firebirdsql+asyn://user:password@host:port/path/to/db[?key=value&key=value...]
+
+The bare ``firebirdsql://`` scheme defaults to the synchronous (``syn``) driver.
+
+Examples
+--------
+
+Local server, default port::
+
+   firebirdsql+syn://sysdba:masterkey@localhost//home/me/databases/my_project.fdb
+
+Remote server on port 3050::
+
+   firebirdsql+syn://sysdba:masterkey@example.com:3050//srv/databases/my_project.fdb
+
+Usage
+++++++++++++++++
+
+Synchronous
+-----------
+
+.. code-block:: python
+
+   from sqlalchemy import create_engine, text
+
+   engine = create_engine(
+       "firebirdsql+syn://sysdba:masterkey@localhost//home/me/databases/my_project.fdb",
+       echo=True,
+   )
+
+   with engine.connect() as conn:
+       result = conn.execute(text("select 1 from rdb$database"))
+       print(result.scalar())
+
+Asynchronous
+------------
+
+.. code-block:: python
+
+   import asyncio
+   from sqlalchemy import text
+   from sqlalchemy.ext.asyncio import create_async_engine
+
+   engine = create_async_engine(
+       "firebirdsql+asyn://sysdba:masterkey@localhost//home/me/databases/my_project.fdb",
+       echo=True,
+   )
+
+   async def main():
+       async with engine.connect() as conn:
+           result = await conn.execute(text("select 1 from rdb$database"))
+           print(result.scalar())
+
+   asyncio.run(main())
+
+How to test
+++++++++++++++++
+
+Clone and install
+--------------------
+
+::
+
+   git clone git@github.com:nakagami/sqlalchemy_firebirdsql.git
+   cd sqlalchemy_firebirdsql
+   python3 -m venv .venv
+   . .venv/bin/activate
+   pip install -e .
+   pip install pytest
+
+Create test database and execute pytest
+-------------------------------------------
+
+::
+
+   prepare-test-environment
+   pytest --db syn
+   pytest --db asyn
+

sqlalchemy_firebirdsql-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqlalchemy_firebirdsql"
+description = "Firebird for SQLAlchemy"
+keywords = ["SQLAlchemy", "Firebird", "firebirdsql"]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Paul Graves-DesLauriers", email="paul@dexmicro.com"},
+    {name = "F.D.Castel"},
+    {name = "Hajime Nakagami", email="nakagami@gmail.com"},
+]
+maintainers = [
+    {name = "Hajime Nakagami", email="nakagami@gmail.com"},
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Database :: Front-Ends",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "sqlalchemy>=2.0",
+    "firebirdsql",
+]
+dynamic = ["readme", "version"]
+
+[project.entry-points."sqlalchemy.dialects"]
+"firebirdsql" = "sqlalchemy_firebirdsql.syn:FBDialect_syn"
+"firebirdsql.syn" = "sqlalchemy_firebirdsql.syn:FBDialect_syn"
+"firebirdsql.asyn" = "sqlalchemy_firebirdsql.asyn:FBDialect_asyn"
+
+[project.scripts]
+prepare-test-environment = "sqlalchemy_firebirdsql:infrastructure.prepare_test_environment"
+
+[tool.setuptools.dynamic]
+readme = {file = ["README.rst"], content-type = "text/x-rst"}
+version = {attr = "sqlalchemy_firebirdsql.__version__"}
+
+[tool.pytest.ini_options]
+markers = [
+    "backend: mark test as a backend-specific test",
+]

sqlalchemy_firebirdsql-0.1.0/setup.cfg

@@ -0,0 +1,13 @@
+[sqla_testing]
+requirement_cls = sqlalchemy_firebirdsql.requirements:Requirements
+profile_file = test/profiles.txt
+
+[db]
+default = firebirdsql+syn://sysdba:masterkey@localhost//tmp/test_firebirdsql_syn.fdb
+syn = firebirdsql+syn://sysdba:masterkey@localhost//tmp/test_firebirdsql_syn.fdb
+asyn = firebirdsql+asyn://sysdba:masterkey@localhost//tmp/test_firebirdsql_asyn.fdb
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlalchemy_firebirdsql-0.1.0/sqlalchemy_firebirdsql/__init__.py

@@ -0,0 +1,12 @@
+# sqlalchemy_firebirdsql/__init__.py
+# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is released under the MIT License: http://www.opensource.org/licenses/mit-license.php
+from .ext import not_similar_to
+from .ext import similar_to
+from .merge import merge
+
+__version__ = "0.1.0"
+
+__all__ = ["merge", "not_similar_to", "similar_to", "__version__"]

sqlalchemy_firebirdsql-0.1.0/sqlalchemy_firebirdsql/asyn.py

@@ -0,0 +1,275 @@
+# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors <see AUTHORS
+# file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+# mypy: ignore-errors
+
+r"""
+.. dialect:: firebirdsql+asyn
+    :name: firebirdsql
+    :dbapi: firebirdsql
+    :connectstring: firebirdsql+asyn://user:password@host:port/path/to/db[?key=value&key=value...]
+
+This dialect should normally be used only with the
+:func:`_asyncio.create_async_engine` engine creation function::
+
+    from sqlalchemy.ext.asyncio import create_async_engine
+
+    engine = create_async_engine(
+        "firebirdsql+asyn://user:password@host:port/path/to/db[?key=value&key=value...]
+    )
+
+"""  # noqa
+from collections import deque
+
+from .base import FBDialect
+from sqlalchemy import pool
+from sqlalchemy import util
+from sqlalchemy.engine import AdaptedConnection
+from sqlalchemy.util.concurrency import asyncio
+from sqlalchemy.util.concurrency import await_fallback
+from sqlalchemy.util.concurrency import await_only
+
+import firebirdsql
+
+
+class AsyncAdapt_firebirdsql_cursor:
+    # TODO: base on connectors/asyncio.py
+    # see #10415
+    server_side = False
+    __slots__ = (
+        "_adapt_connection",
+        "_connection",
+        "await_",
+        "_cursor",
+        "_rows",
+    )
+
+    def __init__(self, adapt_connection):
+        self._adapt_connection = adapt_connection
+        self._connection = adapt_connection._connection
+        self.await_ = adapt_connection.await_
+
+        cursor = self._connection.cursor(adapt_connection.dbapi.Cursor)
+
+        self._cursor = self.await_(cursor.__aenter__())
+        self._rows = deque()
+
+    @property
+    def description(self):
+        return self._cursor.description
+
+    @property
+    def rowcount(self):
+        return self._cursor.rowcount
+
+    @property
+    def arraysize(self):
+        return self._cursor.arraysize
+
+    @arraysize.setter
+    def arraysize(self, value):
+        self._cursor.arraysize = value
+
+    @property
+    def lastrowid(self):
+        return self._cursor.lastrowid
+
+    def close(self):
+        # note we aren't actually closing the cursor here,
+        # we are just letting GC do it.   to allow this to be async
+        # we would need the Result to change how it does "Safe close cursor".
+        # Firebird "cursors" don't actually have state to be "closed" besides
+        # exhausting rows, which we already have done for sync cursor.
+        self._rows.clear()
+
+    def execute(self, operation, parameters=None):
+        return self.await_(self._execute_async(operation, parameters))
+
+    def executemany(self, operation, seq_of_parameters):
+        return self.await_(
+            self._executemany_async(operation, seq_of_parameters)
+        )
+
+    async def _execute_async(self, operation, parameters):
+        async with self._adapt_connection._execute_mutex:
+            result = await self._cursor.execute(operation, parameters)
+
+            if not self.server_side:
+                # firebirdsql.aio has a "fake" async result, so we have to pull it out
+                # of that here since our default result is not async.
+                # we could just as easily grab "_rows" here and be done with it
+                # but this is safer.
+                self._rows = deque(await self._cursor.fetchall())
+            return result
+
+    async def _executemany_async(self, operation, seq_of_parameters):
+        async with self._adapt_connection._execute_mutex:
+            return await self._cursor.executemany(operation, seq_of_parameters)
+
+    def setinputsizes(self, *inputsizes):
+        pass
+
+    def __iter__(self):
+        while self._rows:
+            yield self._rows.popleft()
+
+    def fetchone(self):
+        if self._rows:
+            return self._rows.popleft()
+        else:
+            return None
+
+    def fetchmany(self, size=None):
+        if size is None:
+            size = self.arraysize
+
+        rr = self._rows
+        return [rr.popleft() for _ in range(min(size, len(rr)))]
+
+    def fetchall(self):
+        retval = list(self._rows)
+        self._rows.clear()
+        return retval
+
+
+class AsyncAdapt_firebirdsql_connection(AdaptedConnection):
+    # TODO: base on connectors/asyncio.py
+    # see #10415
+    await_ = staticmethod(await_only)
+    __slots__ = ("dbapi", "_execute_mutex")
+
+    def __init__(self, dbapi, connection):
+        self.dbapi = dbapi
+        self._connection = connection
+        self._execute_mutex = asyncio.Lock()
+
+    def ping(self, reconnect):
+        return self.await_(self._connection.ping(reconnect))
+
+    def character_set_name(self):
+        return self._connection.character_set_name()
+
+    def autocommit(self, value):
+        self.await_(self._connection.autocommit(value))
+
+    def cursor(self):
+        return AsyncAdapt_firebirdsql_cursor(self)
+
+    def rollback(self):
+        self.await_(self._connection.rollback())
+
+    def commit(self):
+        self.await_(self._connection.commit())
+
+    def terminate(self):
+        # it's not awaitable.
+        self._connection.close()
+
+    def close(self) -> None:
+        self.await_(self._connection.ensure_closed())
+
+
+class AsyncAdaptFallback_firebirdsql_connection(AsyncAdapt_firebirdsql_connection):
+    # TODO: base on connectors/asyncio.py
+    # see #10415
+    __slots__ = ()
+
+    await_ = staticmethod(await_fallback)
+
+
+class AsyncAdapt_firebirdsql_dbapi:
+    def __init__(self, asyn, syn):
+        self.asyn = asyn
+        self.syn = syn
+        self.paramstyle = "qmark"
+        self._init_dbapi_attributes()
+        self.Cursor = self.asyn.AsyncCursor
+
+    def _init_dbapi_attributes(self):
+        for name in (
+            "Warning",
+            "Error",
+            "InterfaceError",
+            "DataError",
+            "DatabaseError",
+            "OperationalError",
+            "InterfaceError",
+            "IntegrityError",
+            "ProgrammingError",
+            "InternalError",
+            "NotSupportedError",
+        ):
+            setattr(self, name, getattr(firebirdsql, name))
+
+        for name in (
+            "NUMBER",
+            "STRING",
+            "DATETIME",
+            "BINARY",
+            "TIMESTAMP",
+            "Binary",
+        ):
+            setattr(self, name, getattr(firebirdsql, name))
+
+    def connect(self, *arg, **kw):
+        async_fallback = kw.pop("async_fallback", False)
+        creator_fn = kw.pop("async_creator_fn", self.asyn.connect)
+
+        if util.asbool(async_fallback):
+            return AsyncAdaptFallback_firebirdsql_connection(
+                self,
+                await_fallback(creator_fn(*arg, **kw)),
+            )
+        else:
+            return AsyncAdapt_firebirdsql_connection(
+                self,
+                await_only(creator_fn(*arg, **kw)),
+            )
+
+
+class FBDialect_asyn(FBDialect):
+    driver = "async"
+    supports_statement_cache = True
+
+    is_async = True
+    has_terminate = True
+
+    @classmethod
+    def import_dbapi(cls):
+        return AsyncAdapt_firebirdsql_dbapi(
+            firebirdsql.aio, firebirdsql
+        )
+
+    @classmethod
+    def get_pool_class(cls, url):
+        async_fallback = url.query.get("async_fallback", False)
+
+        if util.asbool(async_fallback):
+            return pool.FallbackAsyncAdaptedQueuePool
+        else:
+            return pool.AsyncAdaptedQueuePool
+
+    def do_terminate(self, dbapi_connection) -> None:
+        dbapi_connection.terminate()
+
+    def create_connect_args(self, url):
+        opts = url.translate_connect_args(username="user")
+        qry = url.query
+
+        opts.update(qry)
+        return ([], opts)
+
+    def is_disconnect(self, e, connection, cursor):
+        if super().is_disconnect(e, connection, cursor):
+            return True
+        else:
+            str_e = str(e).lower()
+            return "not connected" in str_e
+
+    def get_driver_connection(self, connection):
+        return connection._connection
+
+
+dialect = FBDialect_asyn