feat(sqlalchemy): initial version of sqlalchemy dialect

danielebriggi · danielebriggi · commit 8e0986166410 · 2024-08-26T10:59:18.000Z
diff --git a/.devcontainer/py3.6-dev/Dockerfile b/.devcontainer/py3.6-dev/Dockerfile
@@ -4,3 +4,6 @@ ADD https://dl.yarnpkg.com/debian/pubkey.gpg /etc/apt/trusted.gpg.d/yarn.asc
 
 RUN chmod +r /etc/apt/trusted.gpg.d/*.asc && \
     echo "deb http://dl.yarnpkg.com/debian/ stable main" > /etc/apt/sources.list.d/yarn.list
+
+COPY install-legacy-extensions.sh /usr/local/bin/install-legacy-extensions.sh
+RUN chmod +x /usr/local/bin/install-legacy-extensions.sh
diff --git a/.devcontainer/py3.6-dev/devcontainer.json b/.devcontainer/py3.6-dev/devcontainer.json
@@ -17,29 +17,24 @@
 	// "forwardPorts": [],
 
 	// Use 'postCreateCommand' to run commands after the container is created.
-	// "postCreateCommand": "pip3 install --user -r requirements.txt",
+	"postCreateCommand": "install-legacy-extensions.sh",
 
 	// Configure tool-specific properties.
 	// Py3.6 support (switch extensions to `pre-release` and `install another version`):
 	// Pylance v2022.6.30
 	// Python v2022.8.1
-	// Python Debugger v2023.1.XXX (pre-release version | debugpy v1.5.1)
+	// Python Debugger v2023.1.12492010 (pre-release version | debugpy v1.5.1)
 	// Black Formatter v2022.2.0
 	// Isort v2022.1.11601002 (pre-release)
 	"customizations": {
 		"vscode": {
 			"extensions": [
 				"littlefoxteam.vscode-python-test-adapter",
 				"jkillian.custom-local-formatters",
-				"ms-python.vscode-pylance",
-				"ms-python.python",
-				"ms-python.debugpy",
-				"ms-python.black-formatter",
-				"ms-python.isort",
 				"ms-toolsai.jupyter"
 			]
 		}
-	}
+	},
 
 	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
 	// "remoteUser": "root"
diff --git a/.devcontainer/py3.6-dev/install-legacy-extensions.sh b/.devcontainer/py3.6-dev/install-legacy-extensions.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+code --install-extension "ms-python.python@2022.8.1"
+code --install-extension "ms-python.vscode-pylance@2022.6.30"
+code --install-extension "ms-python.debugpy@2023.1.12492010"
+code --install-extension "ms-python.black-formatter@2022.2.0"
+code --install-extension "ms-python.isort@2022.1.11601002"
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@
   <img src="https://sqlitecloud.io/social/logo.png" height="300" alt="SQLite Cloud logo">
 </p>
 
-![Build Status](https://github.com/sqlitecloud/sqlitecloud-py/actions/workflows/deploy.yaml/badge.svg "Build Status")
+![Build Status](https://github.com/sqlitecloud/sqlitecloud-py/actions/workflows/test.yaml/badge.svg "Build Status")
 [![codecov](https://codecov.io/github/sqlitecloud/python/graph/badge.svg?token=38G6FGOWKP)](https://codecov.io/github/sqlitecloud/python)
 ![PyPI - Version](https://img.shields.io/pypi/v/sqlitecloud?link=https%3A%2F%2Fpypi.org%2Fproject%2FSqliteCloud%2F)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/sqlitecloud?link=https%3A%2F%2Fpypi.org%2Fproject%2FSqliteCloud%2F)
diff --git a/sqlalchemy-sqlitecloud/README.md b/sqlalchemy-sqlitecloud/README.md
@@ -0,0 +1,70 @@
+# SQLite Cloud dialect for SQLAlchermy (beta)
+
+This package makes SQLAlchemy to work with SQLite Cloud.
+
+The dialect is based on the `sqlite` dialect included in SQLAlchemy.
+
+## Beta version
+
+This dialect is an early version and it works on Python >= 3.6.
+
+**Tested only on `Python 3.6` and `SQLAlchemy 1.4`.**
+
+The dialect as been tested against the SQLAlchemy `test_suite` as reported in the [documentation](https://github.com/sqlalchemy/sqlalchemy/blob/rel_1_4_53/README.dialects.rst).
+
+You can follow the status of the tests that are still failing [in the dedicated issue](https://github.com/sqlitecloud/sqlitecloud-py/issues/21#issuecomment-2305162632).
+
+References:
+- [Official SQLAlchemy documentation](https://docs.sqlalchemy.org/en/14/index.html)
+- [https://www.sqlalchemy.org/](https://www.sqlalchemy.org/)
+
+
+# Install and Usage
+
+```bash
+$ pip install sqlalchemy-sqlitecloud
+```
+
+> Get your SQLite Cloud connection string from the SQLite Cloud dashboard or register on [sqlitecloud.io](https://sqlitecloud.io) to get one.
+
+Create the SQLAlchemy engine by setting the SQLite Cloud connection string. Add the prefix `sqlite+` like:
+
+```python
+from sqlalchemy import create_engine
+
+engine = create_engine('sqlite+sqlitecloud://mynode.sqlite.io?apikey=key1234')
+```
+
+
+# Run the Test Suite
+
+Install the `sqlitecloud` package with:
+
+```bash
+$ pip install sqlitecloud # last version
+```
+or install the reference to the local version:
+
+
+```bash
+$ cd ../src # sqlitecloud src directory
+$ pip install -e .
+```
+
+Run the test suite with:
+
+```bash
+$ cd sqlalchemy-sqlitecloud
+$ pytest
+```
+
+> Note:  VSCode Test Explorer and VSCode GUI debugger doesn't work because the actual implementation
+is not in the `test/test_suite.py` file. It cannot find the tests source code in the third-parties directory.
+
+Use `pytest --pdb` with `pdb.set_trace()` to debug with command line:
+
+ - `s` step into
+ - `n` next line
+ - `r` jump to the end of the function
+ - `c` continue
+ - `a` print all variables
diff --git a/sqlalchemy-sqlitecloud/pyproject.toml b/sqlalchemy-sqlitecloud/pyproject.toml
@@ -0,0 +1,5 @@
+# Configuration file to store build system requirements for Python projects
+# https://www.python.org/dev/peps/pep-0518/
+
+[tool.pytest.ini_options]
+addopts = "--tb native -v -r fxX --maxfail=25 -p no:warnings --requirements sqlalchemy_sqlitecloud.requirements:Requirements"
diff --git a/sqlalchemy-sqlitecloud/setup.cfg b/sqlalchemy-sqlitecloud/setup.cfg
@@ -0,0 +1,11 @@
+[tool:pytest]
+addopts= --tb native -v -r fxX --maxfail=25 -p no:warnings --requirements sqlalchemy_sqlitecloud.requirements:Requirements
+python_files=test/*test_*.py
+
+[sqla_testing]
+requirement_cls=sqlalchemy_sqlitecloud.requirements:Requirements
+profile_file=test/profiles.txt
+
+[db]
+# SQLite Cloud connection string is set in conftest.py with testing apikey
+#default=sqlite+sqlitecloud://...
diff --git a/sqlalchemy-sqlitecloud/setup.py b/sqlalchemy-sqlitecloud/setup.py
@@ -0,0 +1,5 @@
+entry_points = {
+    "sqlalchemy.dialects": [
+        "sqlite.cloud = sqlalchemy_sqlitecloud.base:SQLiteCloudDialect",
+    ]
+}
diff --git a/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/__init__.py b/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/__init__.py
@@ -0,0 +1,5 @@
+from sqlalchemy.dialects import registry
+
+registry.register(
+    "sqlite.sqlitecloud", "sqlalchemy_sqlitecloud.base", "SQLiteCloudDialect"
+)
diff --git a/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/base.py b/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/base.py
@@ -0,0 +1,133 @@
+import sqlalchemy.types as sqltypes
+from sqlalchemy import util
+from sqlalchemy.dialects.sqlite.base import DATE, DATETIME, SQLiteDialect
+from sqlalchemy.engine.url import URL
+from sqlalchemy.exc import ArgumentError
+from sqlalchemy.pool import NullPool
+
+
+class _SQLite_pysqliteTimeStamp(DATETIME):
+    def bind_processor(self, dialect):
+        if dialect.native_datetime:
+            return None
+        else:
+            return DATETIME.bind_processor(self, dialect)
+
+    def result_processor(self, dialect, coltype):
+        if dialect.native_datetime:
+            return None
+        else:
+            return DATETIME.result_processor(self, dialect, coltype)
+
+
+class _SQLite_pysqliteDate(DATE):
+    def bind_processor(self, dialect):
+        if dialect.native_datetime:
+            return None
+        else:
+            return DATE.bind_processor(self, dialect)
+
+    def result_processor(self, dialect, coltype):
+        if dialect.native_datetime:
+            return None
+        else:
+            return DATE.result_processor(self, dialect, coltype)
+
+
+class SQLiteCloudDialect(SQLiteDialect):
+    default_paramstyle = "qmark"
+    supports_statement_cache = False
+
+    colspecs = util.update_copy(
+        SQLiteDialect.colspecs,
+        {
+            sqltypes.Date: _SQLite_pysqliteDate,
+            sqltypes.TIMESTAMP: _SQLite_pysqliteTimeStamp,
+        },
+    )
+
+    driver = "sqlitecloud"
+
+    @classmethod
+    def dbapi(cls):
+        from sqlitecloud import dbapi2
+
+        return dbapi2
+
+    @classmethod
+    def get_pool_class(cls, url):
+        return NullPool
+
+    def _get_server_version_info(self, connection):
+        return self.dbapi.sqlite_version_info
+
+    def set_isolation_level(self, connection, level):
+        if level != "AUTOCOMMIT":
+            raise ArgumentError(
+                "SQLite Cloud supports only AUTOCOMMIT isolation level."
+            )
+
+        if hasattr(connection, "dbapi_connection"):
+            dbapi_connection = connection.dbapi_connection
+        else:
+            dbapi_connection = connection
+
+        if level == "AUTOCOMMIT":
+            dbapi_connection.isolation_level = None
+        else:
+            dbapi_connection.isolation_level = ""
+            return super(SQLiteCloudDialect, self).set_isolation_level(
+                connection, level
+            )
+
+    def on_connect(self):
+        connect = super(SQLiteCloudDialect, self).on_connect()
+
+        fns = []
+
+        if self.isolation_level is not None:
+
+            def iso_level(conn):
+                self.set_isolation_level(conn, self.isolation_level)
+
+            fns.append(iso_level)
+
+        def connect(conn):  # noqa: F811
+            for fn in fns:
+                fn(conn)
+
+        return connect
+
+    def create_connect_args(self, url: URL):
+        if not url.host:
+            raise ArgumentError(
+                "SQLite Cloud URL is required.\n"
+                "Register on https://sqlitecloud.io/ to get your free SQLite Cloud account.\n"
+                "Valid SQLite Cloud URL are:\n"
+                " sqlite+sqlitecloud:///myuser:mypass@myserver.sqlite.cloud/mydb.sqlite?non_linearizable=true\n"
+                " sqlite+sqlitecloud:///myserver.sqlite.cloud/?apikey=mykey1234"
+            )
+
+        # TODO: this should be the list of SQLite Cloud Config params
+        pysqlite_args = [
+            # ("timeout", float),
+            # ("isolation_level", str),
+            ("detect_types", int),
+        ]
+        opts = url.query
+        pysqlite_opts = {}
+        for key, type_ in pysqlite_args:
+            util.coerce_kw_type(opts, key, type_, dest=pysqlite_opts)
+
+        # sqlitecloud//...
+        url = url.set(drivername="sqlitecloud")
+
+        return ([url.render_as_string(hide_password=False)], pysqlite_opts)
+
+    def is_disconnect(self, e, connection, cursor):
+        return isinstance(
+            e, self.dbapi.ProgrammingError
+        ) and "Cannot operate on a closed database." in str(e)
+
+
+dialect = SQLiteCloudDialect
diff --git a/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/provision.py b/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/provision.py
@@ -0,0 +1,58 @@
+from sqlalchemy.pool import Pool
+from sqlalchemy.testing.provision import (
+    generate_driver_url,
+    post_configure_engine,
+    stop_test_class_outside_fixtures,
+    temp_table_keyword_args,
+)
+
+_drivernames = {
+    "sqlitecloud",
+}
+
+
+@generate_driver_url.for_db("sqlite")
+def generate_driver_url(url, driver, query_str):
+    # eg: sqlite+sqlitecloud://mynode.sqlite.cloud/sqlalchemy_cloud.db?apikey=key123
+    return url
+
+
+@post_configure_engine.for_db("sqlite")
+def _sqlite_post_configure_engine(url, engine, follower_ident):
+    from sqlalchemy import event
+
+    main_database = "sqlalchemy_sqlitecloud.db"
+    attached_database = "sqlalchemy_sqlitecloud_test_schema.db"
+
+    _create_dbs(url, main_database)
+    _create_dbs(url, attached_database)
+
+    @event.listens_for(Pool, "connect")
+    def connect(dbapi_connection, connection_record):
+        # attach the test schema for all new connections,
+        # not just when the engine is first created and connected.
+        # Next connections lost the attached schema.
+        dbapi_connection.execute(f"USE DATABASE {main_database}")
+        dbapi_connection.execute(
+            f'ATTACH DATABASE "{attached_database}" AS test_schema'
+        )
+
+
+def _create_dbs(url, database):
+    import sqlitecloud
+
+    with sqlitecloud.connect(str(url)) as conn:
+        conn.execute(
+            f"REMOVE DATABASE {database} IF EXISTS; "
+            f"CREATE DATABASE {database} IF NOT EXISTS"
+        )
+
+
+@stop_test_class_outside_fixtures.for_db("sqlite")
+def stop_test_class_outside_fixtures(config, db, cls):
+    db.dispose()
+
+
+@temp_table_keyword_args.for_db("sqlite")
+def _sqlite_temp_table_keyword_args(cfg, eng):
+    return {"prefixes": ["TEMPORARY"]}
diff --git a/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/requirements.py b/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/requirements.py
@@ -0,0 +1,45 @@
+from sqlalchemy.testing import exclusions
+from sqlalchemy.testing.requirements import SuiteRequirements
+
+supported = exclusions.open
+unsupported = exclusions.closed
+
+
+class Requirements(SuiteRequirements):
+    @property
+    def table_ddl_if_exists(self):
+        """target platform supports IF NOT EXISTS / IF EXISTS for tables."""
+
+        return supported()
+
+    @property
+    def index_ddl_if_exists(self):
+        """target platform supports IF NOT EXISTS / IF EXISTS for indexes."""
+
+        return supported()
+
+    @property
+    def implicitly_named_constraints(self):
+        """target database must apply names to unnamed constraints."""
+
+        return unsupported()
+
+    @property
+    def reflects_pk_names(self):
+        """https://www.sqlite.org/syntax/column-constraint.html"""
+
+        return supported()
+
+    @property
+    def views(self):
+        """Target database must support VIEWs."""
+
+        return supported()
+
+    @property
+    def dbapi_lastrowid(self):
+        """target platform includes a 'lastrowid' accessor on the DBAPI
+        cursor object.
+
+        """
+        return supported()
diff --git a/sqlalchemy-sqlitecloud/test/__init__.py b/sqlalchemy-sqlitecloud/test/__init__.py
diff --git a/sqlalchemy-sqlitecloud/test/conftest.py b/sqlalchemy-sqlitecloud/test/conftest.py
diff --git a/sqlalchemy-sqlitecloud/test/profiles.txt b/sqlalchemy-sqlitecloud/test/profiles.txt
diff --git a/sqlalchemy-sqlitecloud/test/test_suite.py b/sqlalchemy-sqlitecloud/test/test_suite.py
diff --git a/src/tests/conftest.py b/src/tests/conftest.py
