sql-athame 0.4.0a9__tar.gz → 0.4.0a11__tar.gz

sql_athame-0.4.0a11/.bumpversion.cfg

@@ -0,0 +1,19 @@
+[bumpversion]
+current_version = 0.4.0-alpha-11
+parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(-(?P<release>.*)-(?P<build>\d+))?
+serialize = 
+	{major}.{minor}.{patch}-{release}-{build}
+	{major}.{minor}.{patch}
+commit = True
+
+[bumpversion:file:pyproject.toml]
+
+[bumpversion:part:release]
+first_value = regular
+optional_value = regular
+values = 
+	alpha
+	beta
+	rc
+	test
+	regular

sql_athame-0.4.0a11/.editorconfig

@@ -0,0 +1,7 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4

sql_athame-0.4.0a11/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: publish
+
+on:
+  push:
+    tags:
+      - 'v**'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    env:
+      UV_PUBLISH_TOKEN: ${{ secrets.POETRY_PYPI_TOKEN_PYPI }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.6.6"
+          enable-cache: true
+          python-version: '3.12'
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - run: uv build
+      - run: uv publish

sql_athame-0.4.0a11/.github/workflows/test.yml

@@ -0,0 +1,48 @@
+name: test
+
+on:
+  push:
+    branches:
+      - '**'
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        python-version:
+          - '3.9'
+          - '3.10'
+          - '3.11'
+          - '3.12'
+          - '3.13'
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:16
+        ports:
+          - 5432:5432
+        env:
+          POSTGRES_PASSWORD: password
+    env:
+      PGPORT: 5432
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.6.6"
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - run: uv sync
+      - run: uv run ruff check
+      - run: uv run ruff format --diff
+        if: success() || failure()
+      - run: uv run mypy sql_athame/**.py tests/**.py
+        if: success() || failure()
+      - run: uv run pytest
+        if: success() || failure()

sql_athame-0.4.0a11/.gitignore

@@ -0,0 +1,9 @@
+*.egg-info
+.*_cache
+.coverage
+.venv
+__pycache__
+pip-wheel-metadata
+
+/dist
+/results

{sql_athame-0.4.0a9 → sql_athame-0.4.0a11}/PKG-INFO

@@ -1,22 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sql-athame
-Version: 0.4.0a9
+Version: 0.4.0a11
 Summary: Python tool for slicing and dicing SQL
-Home-page: https://github.com/bdowning/sql-athame
+Project-URL: homepage, https://github.com/bdowning/sql-athame
+Project-URL: repository, https://github.com/bdowning/sql-athame
+Author-email: Brian Downing <bdowning@lavos.net>
 License: MIT
-Author: Brian Downing
-Author-email: bdowning@lavos.net
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: asyncpg
-Requires-Dist: asyncpg ; extra == "asyncpg"
+License-File: LICENSE
+Requires-Python: <4.0,>=3.9
 Requires-Dist: typing-extensions
-Project-URL: Repository, https://github.com/bdowning/sql-athame
+Provides-Extra: asyncpg
+Requires-Dist: asyncpg; extra == 'asyncpg'
 Description-Content-Type: text/markdown
 
 # sql-athame
@@ -405,4 +399,3 @@ MIT.
 
 ---
 Copyright (c) 2019, 2020 Brian Downing
-

sql_athame-0.4.0a11/docker-compose.yml

@@ -0,0 +1,9 @@
+version: "2"
+
+services:
+  postgres:
+    image: postgres:12
+    ports:
+      - 29329:5432
+    environment:
+      POSTGRES_PASSWORD: password

{sql_athame-0.4.0a9 → sql_athame-0.4.0a11}/pyproject.toml

@@ -1,37 +1,44 @@
-[tool.poetry]
+[project]
+authors = [
+    {name = "Brian Downing", email = "bdowning@lavos.net"},
+]
+license = {text = "MIT"}
+requires-python = "<4.0,>=3.9"
+dependencies = [
+    "typing-extensions",
+]
 name = "sql-athame"
-version = "0.4.0-alpha-9"
+version = "0.4.0-alpha-11"
 description = "Python tool for slicing and dicing SQL"
-authors = ["Brian Downing <bdowning@lavos.net>"]
-license = "MIT"
 readme = "README.md"
+
+[project.urls]
 homepage = "https://github.com/bdowning/sql-athame"
 repository = "https://github.com/bdowning/sql-athame"
 
-[tool.poetry.extras]
-asyncpg = ["asyncpg"]
-
-[tool.poetry.dependencies]
-python = "^3.9"
-asyncpg = { version = "*", optional = true }
-typing-extensions = "*"
+[project.optional-dependencies]
+asyncpg = [
+    "asyncpg",
+]
 
-[tool.poetry.group.dev.dependencies]
-pytest = "*"
-mypy = "*"
-flake8 = "*"
-ipython = "*"
-pytest-cov = "*"
-bump2version = "*"
-asyncpg = "*"
-pytest-asyncio = "*"
-grip = "*"
-SQLAlchemy = "*"
-ruff = "*"
+[dependency-groups]
+dev = [
+    "SQLAlchemy",
+    "asyncpg",
+    "bump2version",
+    "flake8",
+    "grip",
+    "ipython",
+    "mypy",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "ruff",
+]
 
 [build-system]
-requires = ["poetry>=0.12"]
-build-backend = "poetry.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
 [tool.ruff]
 target-version = "py39"
@@ -62,7 +69,6 @@ ignore = [
     "E501",    # line too long
     "E721",    # type checks, currently broken
     "ISC001",  # conflicts with ruff format
-    "PT004",   # Fixture `...` does not return anything, add leading underscore
     "RET505",  # Unnecessary `else` after `return` statement
     "RET506",  # Unnecessary `else` after `raise` statement
 ]

sql_athame-0.4.0a11/run

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+usage=()
+
+usage+=("  $0 tests - run tests")
+tests() {
+    uv run pytest "$@"
+    lint
+}
+
+usage+=("  $0 refmt - reformat code")
+refmt() {
+    uv run ruff check --select I --fix
+    uv run ruff format
+}
+
+usage+=("  $0 lint - run linting")
+lint() {
+    uv run ruff check
+    uv run ruff format --diff
+    uv run mypy sql_athame/**.py tests/**.py
+}
+
+usage+=("  $0 bump2version {major|minor|patch} - bump version number")
+bump2version() {
+    uv run bump2version "$@"
+}
+
+cmd=$1
+shift
+
+if ! declare -f "$cmd" >/dev/null; then
+    echo "Usage:"
+    for line in "${usage[@]}"; do echo "$line"; done
+    exit 1
+fi
+
+set -o xtrace
+
+"$cmd" "$@"

sql_athame-0.4.0a11/sql_athame/__init__.py

@@ -0,0 +1,2 @@
+from .base import Fragment, sql
+from .dataclasses import ColumnInfo, ModelBase, ReplaceMultiplePlan

{sql_athame-0.4.0a9 → sql_athame-0.4.0a11}/sql_athame/dataclasses.py

@@ -8,6 +8,7 @@ from typing import (
     Annotated,
     Any,
     Callable,
+    Generic,
     Optional,
     TypeVar,
     Union,
@@ -156,7 +157,7 @@ class ModelBase:
     _cache: dict[tuple, Any]
     table_name: str
     primary_key_names: tuple[str, ...]
-    array_safe_insert: bool
+    insert_multiple_mode: str
 
     def __init_subclass__(
         cls,
@@ -168,12 +169,9 @@ class ModelBase:
     ):
         cls._cache = {}
         cls.table_name = table_name
-        if insert_multiple_mode == "array_safe":
-            cls.array_safe_insert = True
-        elif insert_multiple_mode == "unnest":
-            cls.array_safe_insert = False
-        else:
+        if insert_multiple_mode not in ("array_safe", "unnest", "executemany"):
             raise ValueError("Unknown `insert_multiple_mode`")
+        cls.insert_multiple_mode = insert_multiple_mode
         if isinstance(primary_key, str):
             cls.primary_key_names = (primary_key,)
         else:
@@ -251,7 +249,7 @@ class ModelBase:
             if ci.field.name not in exclude:
                 if ci.serialize:
                     env[f"_ser_{ci.field.name}"] = ci.serialize
-                    func.append(f"_ser_{ci.field.name}(self.{ci.field.name}), ")
+                    func.append(f"_ser_{ci.field.name}(self.{ci.field.name}),")
                 else:
                     func.append(f"self.{ci.field.name},")
         func += ["]"]
@@ -356,7 +354,17 @@ class ModelBase:
         return query
 
     @classmethod
-    async def select_cursor(
+    async def cursor_from(
+        cls: type[T],
+        connection: Connection,
+        query: Fragment,
+        prefetch: int = 1000,
+    ) -> AsyncGenerator[T, None]:
+        async for row in connection.cursor(*query, prefetch=prefetch):
+            yield cls.from_mapping(row)
+
+    @classmethod
+    def select_cursor(
         cls: type[T],
         connection: Connection,
         order_by: Union[FieldNames, str] = (),
@@ -364,11 +372,19 @@ class ModelBase:
         where: Where = (),
         prefetch: int = 1000,
     ) -> AsyncGenerator[T, None]:
-        async for row in connection.cursor(
-            *cls.select_sql(order_by=order_by, for_update=for_update, where=where),
+        return cls.cursor_from(
+            connection,
+            cls.select_sql(order_by=order_by, for_update=for_update, where=where),
             prefetch=prefetch,
-        ):
-            yield cls.from_mapping(row)
+        )
+
+    @classmethod
+    async def fetch_from(
+        cls: type[T],
+        connection_or_pool: Union[Connection, Pool],
+        query: Fragment,
+    ) -> list[T]:
+        return [cls.from_mapping(row) for row in await connection_or_pool.fetch(*query)]
 
     @classmethod
     async def select(
@@ -378,12 +394,10 @@ class ModelBase:
         for_update: bool = False,
         where: Where = (),
     ) -> list[T]:
-        return [
-            cls.from_mapping(row)
-            for row in await connection_or_pool.fetch(
-                *cls.select_sql(order_by=order_by, for_update=for_update, where=where)
-            )
-        ]
+        return await cls.fetch_from(
+            connection_or_pool,
+            cls.select_sql(order_by=order_by, for_update=for_update, where=where),
+        )
 
     @classmethod
     def create_sql(cls: type[T], **kwargs: Any) -> Fragment:
@@ -505,6 +519,37 @@ class ModelBase:
             ),
         )
 
+    @classmethod
+    def insert_multiple_executemany_chunk_sql(
+        cls: type[T], chunk_size: int
+    ) -> Fragment:
+        def generate() -> Fragment:
+            columns = len(cls.column_info())
+            values = ", ".join(
+                f"({', '.join(f'${i}' for i in chunk)})"
+                for chunk in chunked(range(1, columns * chunk_size + 1), columns)
+            )
+            return sql(
+                "INSERT INTO {table} ({fields}) VALUES {values}",
+                table=cls.table_name_sql(),
+                fields=sql.list(cls.field_names_sql()),
+                values=sql.literal(values),
+            ).flatten()
+
+        return cls._cached(
+            ("insert_multiple_executemany_chunk", chunk_size),
+            generate,
+        )
+
+    @classmethod
+    async def insert_multiple_executemany(
+        cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+    ) -> None:
+        args = [r.field_values() for r in rows]
+        query = cls.insert_multiple_executemany_chunk_sql(1).query()[0]
+        if args:
+            await connection_or_pool.executemany(query, args)
+
     @classmethod
     async def insert_multiple_unnest(
         cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
@@ -526,11 +571,28 @@ class ModelBase:
     async def insert_multiple(
         cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
-        if cls.array_safe_insert:
+        if cls.insert_multiple_mode == "executemany":
+            await cls.insert_multiple_executemany(connection_or_pool, rows)
+            return "INSERT"
+        elif cls.insert_multiple_mode == "array_safe":
             return await cls.insert_multiple_array_safe(connection_or_pool, rows)
         else:
             return await cls.insert_multiple_unnest(connection_or_pool, rows)
 
+    @classmethod
+    async def upsert_multiple_executemany(
+        cls: type[T],
+        connection_or_pool: Union[Connection, Pool],
+        rows: Iterable[T],
+        insert_only: FieldNamesSet = (),
+    ) -> None:
+        args = [r.field_values() for r in rows]
+        query = cls.upsert_sql(
+            cls.insert_multiple_executemany_chunk_sql(1), exclude=insert_only
+        ).query()[0]
+        if args:
+            await connection_or_pool.executemany(query, args)
+
     @classmethod
     async def upsert_multiple_unnest(
         cls: type[T],
@@ -565,7 +627,12 @@ class ModelBase:
         rows: Iterable[T],
         insert_only: FieldNamesSet = (),
     ) -> str:
-        if cls.array_safe_insert:
+        if cls.insert_multiple_mode == "executemany":
+            await cls.upsert_multiple_executemany(
+                connection_or_pool, rows, insert_only=insert_only
+            )
+            return "INSERT"
+        elif cls.insert_multiple_mode == "array_safe":
             return await cls.upsert_multiple_array_safe(
                 connection_or_pool, rows, insert_only=insert_only
             )
@@ -588,7 +655,7 @@ class ModelBase:
         return env["equal_ignoring"]
 
     @classmethod
-    async def replace_multiple(
+    async def plan_replace_multiple(
         cls: type[T],
         connection: Connection,
         rows: Union[Iterable[T], Iterable[Mapping[str, Any]]],
@@ -596,7 +663,7 @@ class ModelBase:
         where: Where,
         ignore: FieldNamesSet = (),
         insert_only: FieldNamesSet = (),
-    ) -> tuple[list[T], list[T], list[T]]:
+    ) -> "ReplaceMultiplePlan[T]":
         ignore = sorted(set(ignore) | set(insert_only))
         equal_ignoring = cls._cached(
             ("equal_ignoring", tuple(ignore)),
@@ -620,14 +687,23 @@ class ModelBase:
 
         created = list(pending.values())
 
-        if created or updated:
-            await cls.upsert_multiple(
-                connection, (*created, *updated), insert_only=insert_only
-            )
-        if deleted:
-            await cls.delete_multiple(connection, deleted)
+        return ReplaceMultiplePlan(cls, insert_only, created, updated, deleted)
 
-        return created, updated, deleted
+    @classmethod
+    async def replace_multiple(
+        cls: type[T],
+        connection: Connection,
+        rows: Union[Iterable[T], Iterable[Mapping[str, Any]]],
+        *,
+        where: Where,
+        ignore: FieldNamesSet = (),
+        insert_only: FieldNamesSet = (),
+    ) -> tuple[list[T], list[T], list[T]]:
+        plan = await cls.plan_replace_multiple(
+            connection, rows, where=where, ignore=ignore, insert_only=insert_only
+        )
+        await plan.execute(connection)
+        return plan.cud
 
     @classmethod
     def _get_differences_ignoring_fn(
@@ -694,6 +770,33 @@ class ModelBase:
         return created, updated_triples, deleted
 
 
+@dataclass
+class ReplaceMultiplePlan(Generic[T]):
+    model_class: type[T]
+    insert_only: FieldNamesSet
+    created: list[T]
+    updated: list[T]
+    deleted: list[T]
+
+    @property
+    def cud(self) -> tuple[list[T], list[T], list[T]]:
+        return (self.created, self.updated, self.deleted)
+
+    async def execute_upserts(self, connection: Connection) -> None:
+        if self.created or self.updated:
+            await self.model_class.upsert_multiple(
+                connection, (*self.created, *self.updated), insert_only=self.insert_only
+            )
+
+    async def execute_deletes(self, connection: Connection) -> None:
+        if self.deleted:
+            await self.model_class.delete_multiple(connection, self.deleted)
+
+    async def execute(self, connection: Connection) -> None:
+        await self.execute_upserts(connection)
+        await self.execute_deletes(connection)
+
+
 def chunked(lst, n):
     if type(lst) is not list:
         lst = list(lst)