sqlalchemy-declarative-extensions 0.16.10__tar.gz → 0.17.0__tar.gz

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/.readthedocs.yml

@@ -4,7 +4,7 @@ sphinx:
   configuration: docs/source/conf.py
 
 build:
-  os: ubuntu-20.04
+  os: ubuntu-24.04
   tools:
     python: "3.10"
 

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/CHANGELOG.md

@@ -1,9 +1,19 @@
 # Changelog
 
+## 0.17
+
 ### 0.17.0
 
+- feat: Add support for declaring triggers in __table_args__.
+- feat: Add PARALLEL, STRICT and LEAKPROOF support to pg functions.
+- fix: Rename FunctionVolatility and FunctionParallel members to lowercase.
+
 ## 0.16
 
+### 0.16.11
+
+- fix: Correlate the extension-schema check in pg triggers_query.
+
 ### 0.16.10
 
 - fix: TypeError breaking constraints on declared views.

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sqlalchemy-declarative-extensions
-Version: 0.16.10
+Version: 0.17.0
 Summary: Library to declare additional kinds of objects not natively supported by SQLAlchemy/Alembic.
 Project-URL: documentation, https://sqlalchemy-declarative-extensions.readthedocs.io/en/latest/
 Project-URL: homepage, https://sqlalchemy-declarative-extensions.readthedocs.io/en/latest/

sqlalchemy_declarative_extensions-0.17.0/docs/source/triggers.md

@@ -0,0 +1,97 @@
+# Triggers
+
+```python
+from sqlalchemy.orm import declarative_base
+from sqlalchemy_declarative_extensions import declarative_database, Function, Functions, Triggers
+from sqlalchemy_declarative_extensions.dialects.postgresql import Trigger
+
+_Base = declarative_base()
+
+
+@declarative_database
+class Base(_Base):
+    __abstract__ = True
+
+    functions = Functions().are(
+        Function(
+            "fancy_trigger",
+            """
+            BEGIN
+            INSERT INTO foo (id) select NEW.id + 1;
+            RETURN NULL;
+            END
+            """,
+            language="plpgsql",
+            returns="trigger",
+        )
+    )
+
+    triggers = Triggers().are(
+        Trigger.after("insert", on="foo", execute="fancy_trigger")
+        .named("on_insert_foo")
+        .when("pg_trigger_depth() < 1")
+        .for_each_row(),
+    )
+```
+
+```{note}
+Triggers options are wildly different across dialects. As such, you should always use
+the dialect-specific `sqlalchemy_declarative_extensions.trigger.base.Trigger` subclasses.
+```
+
+```{note}
+Trigger behavior not fully implemented at current time, although it **should** be functional for
+the options it does support. Any ability to instantiate an object which produces a syntax error
+should be considered a bug. Additionally, feature requests for supporting more trigger options
+are welcome!
+```
+
+## Table-level triggers
+
+Unlike most other object types, a trigger always targets exactly one table. It can
+therefore be declared inline on that table instead, through `__table_args__` (or the
+positional arguments of a [Table](sqlalchemy.schema.Table)), in the same way you would
+declare an `Index` or `UniqueConstraint`.
+
+```python
+from sqlalchemy import Column, types
+from sqlalchemy_declarative_extensions.dialects.postgresql import Trigger
+
+
+class Foo(Base):
+    __tablename__ = "foo"
+    __table_args__ = (
+        Trigger.after("insert", execute="fancy_trigger")
+        .named("on_insert_foo")
+        .when("pg_trigger_depth() < 1")
+        .for_each_row(),
+    )
+
+    id = Column(types.Integer(), primary_key=True)
+```
+
+Declared this way, `on` is inferred from the table being attached to (schema-qualified,
+where that table declares a non-default schema), and need not be supplied. Supplying an
+`on` which disagrees with that table is an error.
+
+The resulting trigger is registered against the same `MetaData` as one declared through
+`Triggers`, so the two styles can be freely mixed, and both are picked up by alembic
+autogeneration. The trigger object itself is not mutated by being attached, so a single
+definition can be shared among multiple tables.
+
+```{note}
+`name`, unlike `on`, is **not** inferred. A trigger attached to a table must be given one,
+either through `name=` or `.named(...)`, else a `ValueError` is raised at declaration time.
+```
+
+```{note}
+The `MetaData` must have been set up (i.e. `declarative_database` applied, or
+`declare_database` called) **before** the models which attach triggers are defined. This is
+the natural ordering, but it does mean that doing so afterwards will discard any
+already-attached table-level triggers.
+```
+
+```{eval-rst}
+.. autoapimodule:: sqlalchemy_declarative_extensions.trigger.base
+   :members: Trigger, Triggers, register_trigger
+```

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlalchemy-declarative-extensions"
-version = "0.16.10"
+version = "0.17.0"
 authors = [{ name = "Dan Cardin", email = "ddcardin@gmail.com" }]
 description = "Library to declare additional kinds of objects not natively supported by SQLAlchemy/Alembic."
 license = { file = "LICENSE" }

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/src/sqlalchemy_declarative_extensions/dialects/mysql/trigger.py

@@ -48,8 +48,9 @@ class Trigger(base.Trigger):
     def before(
         cls,
         event: TriggerEvents | str,
-        on: str,
+        *,
         execute: str,
+        on: str = "",
         name: str = "",
     ):
         return cls(
@@ -64,8 +65,9 @@ class Trigger(base.Trigger):
     def after(
         cls,
         event: TriggerEvents | str,
-        on: str,
+        *,
         execute: str,
+        on: str = "",
         name: str = "",
     ):
         return cls(

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/src/sqlalchemy_declarative_extensions/dialects/postgresql/__init__.py

@@ -1,5 +1,6 @@
 from sqlalchemy_declarative_extensions.dialects.postgresql.function import (
     Function,
+    FunctionParallel,
     FunctionParam,
     FunctionReturn,
     FunctionSecurity,
@@ -45,6 +46,7 @@ __all__ = [
     "DefaultGrantTypes",
     "Function",
     "FunctionGrants",
+    "FunctionParallel",
     "FunctionParam",
     "FunctionReturn",
     "FunctionSecurity",

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/src/sqlalchemy_declarative_extensions/dialects/postgresql/function.py

@@ -34,22 +34,24 @@ class FunctionSecurity(enum.Enum):
     definer = "DEFINER"
 
 
-@enum.unique
 class FunctionVolatility(enum.Enum):
-    VOLATILE = "VOLATILE"
-    STABLE = "STABLE"
-    IMMUTABLE = "IMMUTABLE"
+    volatile = "VOLATILE"
+    stable = "STABLE"
+    immutable = "IMMUTABLE"
 
-    @classmethod
-    def from_provolatile(cls, provolatile: str) -> FunctionVolatility:
-        """Convert a `pg_proc.provolatile` value to a `FunctionVolatility` enum."""
-        if provolatile == "v":
-            return cls.VOLATILE
-        if provolatile == "s":
-            return cls.STABLE
-        if provolatile == "i":
-            return cls.IMMUTABLE
-        raise ValueError(f"Invalid volatility: {provolatile}")
+    VOLATILE = volatile
+    STABLE = stable
+    IMMUTABLE = immutable
+
+
+class FunctionParallel(enum.Enum):
+    unsafe = "UNSAFE"
+    restricted = "RESTRICTED"
+    safe = "SAFE"
+
+    UNSAFE = unsafe
+    RESTRICTED = restricted
+    SAFE = safe
 
 
 @dataclass
@@ -62,7 +64,10 @@ class Function(base.Function):
     security: FunctionSecurity = FunctionSecurity.invoker
     returns: FunctionReturn | str | None = None  # type: ignore
     parameters: Sequence[FunctionParam | str] | None = None  # type: ignore
-    volatility: FunctionVolatility = FunctionVolatility.VOLATILE
+    volatility: FunctionVolatility = FunctionVolatility.volatile
+    parallel: FunctionParallel = FunctionParallel.unsafe
+    strict: bool = False
+    leakproof: bool = False
 
     @property
     def _has_sqlbody(self) -> bool:
@@ -91,9 +96,18 @@ class Function(base.Function):
         if self.security == FunctionSecurity.definer:
             components.append("SECURITY DEFINER")
 
-        if self.volatility != FunctionVolatility.VOLATILE:
+        if self.volatility != FunctionVolatility.volatile:
             components.append(self.volatility.value)
 
+        if self.strict:
+            components.append("STRICT")
+
+        if self.leakproof:
+            components.append("LEAKPROOF")
+
+        if self.parallel != FunctionParallel.unsafe:
+            components.append(f"PARALLEL {self.parallel.value}")
+
         components.append(f"LANGUAGE {self.language}")
         if self._has_sqlbody:
             components.append(self.definition)

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/src/sqlalchemy_declarative_extensions/dialects/postgresql/query.py

@@ -14,6 +14,7 @@ from sqlalchemy_declarative_extensions.dialects.postgresql.acl import (
 )
 from sqlalchemy_declarative_extensions.dialects.postgresql.function import (
     Function,
+    FunctionParallel,
     FunctionParam,
     FunctionSecurity,
     FunctionVolatility,
@@ -65,6 +66,21 @@ EXTENSION_TRIGGERS = {
     "postgis_topology": {"layer_integrity_checks": "topology.layer"},
 }
 
+FUNCTION_SECURITY = {
+    True: FunctionSecurity.definer,
+    False: FunctionSecurity.invoker,
+}
+FUNCTION_VOLATILITY = {
+    "v": FunctionVolatility.volatile,
+    "s": FunctionVolatility.stable,
+    "i": FunctionVolatility.immutable,
+}
+FUNCTION_PARALLEL = {
+    "u": FunctionParallel.unsafe,
+    "r": FunctionParallel.restricted,
+    "s": FunctionParallel.safe,
+}
+
 
 def get_schemas_postgresql(connection: Connection):
     from sqlalchemy_declarative_extensions.schema.base import Schema
@@ -227,33 +243,31 @@ def get_functions_postgresql(connection: Connection) -> Sequence[BaseFunction]:
 
     functions = []
     functions_query = get_functions_query(connection.dialect.server_version_info)
-
     for f in connection.execute(functions_query).fetchall():
         name = f.name
         definition = f.source
         language = f.language
         schema = f.schema if f.schema != "public" else None
-
+        parameters = [
+            FunctionParam(name, type, default, mode)
+            for name, type, default, mode in zip_longest(
+                f.arg_names or [],
+                f.arg_types or [],
+                f.arg_defaults or [],
+                f.arg_modes or [],
+            )
+        ]
         function = Function(
-            parameters=[
-                FunctionParam(name, type, default, mode)
-                for name, type, default, mode in zip_longest(
-                    f.arg_names or [],
-                    f.arg_types or [],
-                    f.arg_defaults or [],
-                    f.arg_modes or [],
-                )
-            ],
-            volatility=FunctionVolatility.from_provolatile(f.volatility),
+            parameters=parameters,
             name=name,
             definition=definition,
             language=language,
             schema=schema,
-            security=(
-                FunctionSecurity.definer
-                if f.security_definer
-                else FunctionSecurity.invoker
-            ),
+            volatility=FUNCTION_VOLATILITY[f.volatility],
+            security=FUNCTION_SECURITY[f.security_definer],
+            parallel=FUNCTION_PARALLEL[f.parallel],
+            strict=f.strict,
+            leakproof=f.leakproof,
             returns=f.return_type_string or f.base_return_type,
         )
         functions.append(function)

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/src/sqlalchemy_declarative_extensions/dialects/postgresql/schema.py

@@ -115,6 +115,9 @@ pg_proc = table(
     column("prolang"),
     column("prorettype"),
     column("prosecdef"),
+    column("proparallel"),
+    column("proisstrict"),
+    column("proleakproof"),
     column("prokind"),
     column("provolatile"),
     column("pronargs"),
@@ -376,6 +379,9 @@ def get_functions_query(version_info):
             pg_type.c.typname.label("base_return_type"),
             source.label("source"),
             pg_proc.c.prosecdef.label("security_definer"),
+            cast(pg_proc.c.proparallel, Text).label("parallel"),
+            pg_proc.c.proisstrict.label("strict"),
+            pg_proc.c.proleakproof.label("leakproof"),
             cast(pg_proc.c.prokind, Text).label("kind"),
             func.pg_get_function_arguments(pg_proc.c.oid).label("parameters"),
             cast(pg_proc.c.provolatile, Text).label("volatility"),
@@ -450,6 +456,6 @@ triggers_query = (
         .join(proc_nsp, pg_proc.c.pronamespace == proc_nsp.c.oid)
     )
     .where(pg_trigger.c.tgisinternal.is_(False))
-    .where(_schema_not_from_extension())
+    .where(_schema_not_from_extension(rel_nsp.c.oid))
     .where(_not_from_extension(pg_trigger.c.oid, "pg_trigger"))
 )

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/src/sqlalchemy_declarative_extensions/dialects/postgresql/trigger.py

@@ -100,7 +100,7 @@ class Trigger(base.Trigger):
 
     @classmethod
     def before(
-        cls, *events: TriggerEvents | str, on: str, execute: str, name: str = ""
+        cls, *events: TriggerEvents | str, execute: str, on: str = "", name: str = ""
     ):
         return cls(
             time=TriggerTimes.before,
@@ -111,7 +111,9 @@ class Trigger(base.Trigger):
         )
 
     @classmethod
-    def after(cls, *events: TriggerEvents | str, on: str, execute: str, name: str = ""):
+    def after(
+        cls, *events: TriggerEvents | str, execute: str, on: str = "", name: str = ""
+    ):
         return cls(
             time=TriggerTimes.after,
             events=TriggerEvents.from_strings(events),
@@ -122,7 +124,7 @@ class Trigger(base.Trigger):
 
     @classmethod
     def instead_of(
-        cls, *events: TriggerEvents | str, on: str, execute: str, name: str = ""
+        cls, *events: TriggerEvents | str, execute: str, on: str = "", name: str = ""
     ):
         return cls(
             time=TriggerTimes.instead_of,

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/src/sqlalchemy_declarative_extensions/trigger/base.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field, replace
-from typing import Hashable, Iterable, Sequence
+from typing import Any, Hashable, Iterable, Sequence
 
-from sqlalchemy import MetaData
+from sqlalchemy import MetaData, Table
 from sqlalchemy.engine import Connection
+from sqlalchemy.sql.schema import SchemaItem
 from typing_extensions import Self
 
+from sqlalchemy_declarative_extensions.sql import qualify_name
 from sqlalchemy_declarative_extensions.sqlalchemy import HasMetaData
 
 
 @dataclass
-class Trigger:
+class Trigger(SchemaItem):
     """Describes a generic trigger."""
 
     name: str
@@ -26,6 +28,25 @@ class Trigger:
     def named(self, name: str):
         return replace(self, name=name)
 
+    def _set_parent(self, parent: Any, **kw: Any) -> None:
+        """Attach to the `Table` __table_args__ it was declared in."""
+        if not isinstance(parent, Table):
+            raise ValueError(
+                f"Trigger can only be attached to a `Table`, got: {parent}."
+            )
+
+        on = qualify_name(parent.schema, parent.name)
+        if not self.name:
+            raise ValueError(f"Trigger attached to table '{on}' must have a name.")
+
+        if self.on and self.on != on:
+            raise ValueError(
+                f"Trigger '{self.name}' declares `on='{self.on}'`,"
+                f" which conflicts with the table it is attached to: '{on}'."
+            )
+
+        register_trigger(parent.metadata, replace(self, on=on))
+
     def to_sql_create(self):
         raise NotImplementedError()
 

sqlalchemy_declarative_extensions-0.17.0/tests/dialect/postgresql/test_extension_owned_schema.py

@@ -0,0 +1,47 @@
+from pytest_mock_resources import create_postgres_fixture
+from sqlalchemy import text
+
+from sqlalchemy_declarative_extensions import Triggers
+from sqlalchemy_declarative_extensions.dialects import get_triggers
+from sqlalchemy_declarative_extensions.trigger.compare import compare_triggers
+
+pg = create_postgres_fixture(scope="function", engine_kwargs={"echo": True})
+
+setup = """
+CREATE EXTENSION hstore;
+CREATE SCHEMA ext_owned;
+
+INSERT INTO pg_depend
+    (classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype)
+SELECT 'pg_namespace'::regclass, n.oid, 0, 'pg_extension'::regclass, e.oid, 0, 'e'
+FROM pg_namespace n, pg_extension e
+WHERE n.nspname = 'ext_owned' AND e.extname = 'hstore';
+
+CREATE FUNCTION gimme() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+RETURN NULL;
+END
+$$;
+
+CREATE TABLE foo (id integer primary key);
+CREATE TRIGGER on_insert_foo AFTER INSERT ON foo
+FOR EACH ROW EXECUTE PROCEDURE gimme();
+
+CREATE TABLE ext_owned.bar (id integer primary key);
+CREATE TRIGGER on_insert_bar AFTER INSERT ON ext_owned.bar
+FOR EACH ROW EXECUTE PROCEDURE gimme();
+"""
+
+
+def test_extension_owned_schema_only_excludes_triggers_on_own_tables(pg):
+    with pg.connect() as connection:
+        connection.execute(text(setup))
+        connection.commit()
+        
+        trigger_names = [trigger.name for trigger in get_triggers(connection)]
+        assert trigger_names == ["on_insert_foo"]
+
+        diff = compare_triggers(connection, Triggers())
+
+    diff_trigger_names = [op.trigger.name for op in diff]
+    assert diff_trigger_names == ["on_insert_foo"]

sqlalchemy_declarative_extensions-0.17.0/tests/dialect/postgresql/test_function_attributes.py

@@ -0,0 +1,50 @@
+import pytest
+from pytest_mock_resources import create_postgres_fixture
+from sqlalchemy import text
+
+from sqlalchemy_declarative_extensions import Functions
+from sqlalchemy_declarative_extensions.dialects.postgresql import (
+    Function,
+    FunctionParallel,
+    FunctionVolatility,
+)
+from sqlalchemy_declarative_extensions.function.compare import compare_functions
+
+pg = create_postgres_fixture(scope="function", engine_kwargs={"echo": True})
+
+
+@pytest.mark.parametrize(
+    "attributes",
+    [
+        {},
+        {"parallel": FunctionParallel.restricted},
+        {"parallel": FunctionParallel.safe},
+        {"strict": True},
+        {"leakproof": True},
+        {"parallel": FunctionParallel.safe, "strict": True, "leakproof": True},
+    ],
+)
+def test_function_attributes(pg, attributes):
+    add_function = Function(
+        name="add",
+        definition="SELECT a + b;",
+        parameters=["a integer", "b integer"],
+        returns="INTEGER",
+        **attributes,
+    ).normalize()
+    functions = Functions([add_function])
+    with pg.connect() as connection:
+        connection.execute(text("\n".join(add_function.to_sql_create())))
+        diff = compare_functions(connection, functions)
+    assert diff == []
+
+
+@pytest.mark.parametrize(
+    "alias, member",
+    [
+        (FunctionVolatility.STABLE, FunctionVolatility.stable),
+        (FunctionParallel.SAFE, FunctionParallel.safe),
+    ],
+)
+def test_uppercase_alias_is_lowercase_member(alias, member):
+    assert alias is member

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/tests/dialect/postgresql/test_function_defaults.py

@@ -31,7 +31,7 @@ def test_function_argument_defaults(pg, default_a, default_b, default_c):
             FunctionParam("c", "text", default=default_c),
         ],
         returns="TEXT",
-        volatility=FunctionVolatility.STABLE,
+        volatility=FunctionVolatility.stable,
         language="plpgsql",
     ).normalize()
     create_function = add_label_function.to_sql_create()

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/tests/dialect/postgresql/test_postgres_14_sqlbody.py

@@ -23,7 +23,7 @@ def test_functions(pg):
         definition="RETURN (i + 1)",
         parameters=["i integer"],
         returns="INTEGER",
-        volatility=FunctionVolatility.STABLE,
+        volatility=FunctionVolatility.stable,
     ).normalize()
     create_function = add_stable_function.to_sql_create()
     functions = Functions([add_stable_function])

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/tests/examples/test_function_create_pg_sqlbody/models.py

@@ -23,7 +23,7 @@ class Base(_Base):  # type: ignore
             "RETURN (i + 1)",
             parameters=["i integer"],
             returns="INTEGER",
-            volatility=FunctionVolatility.STABLE,
+            volatility=FunctionVolatility.stable,
         ),
         # NEW FUNCTION: Multiple params, RETURNS TABLE
         Function(
@@ -39,7 +39,7 @@ class Base(_Base):  # type: ignore
             parameters=["group_ids integer[]"],
             returns=FunctionReturn(table=["id integer", "name text"]),
             language="sql",
-            volatility=FunctionVolatility.STABLE,
+            volatility=FunctionVolatility.stable,
         ),
     )
 

{sqlalchemy_declarative_extensions-0.16.10 → sqlalchemy_declarative_extensions-0.17.0}/tests/examples/test_function_create_with_params_postgresql/models.py

@@ -23,7 +23,7 @@ class Base(_Base):  # type: ignore
             "SELECT i + 1;",
             parameters=["i integer"],
             returns="INTEGER",
-            volatility=FunctionVolatility.STABLE,
+            volatility=FunctionVolatility.stable,
         ),
         # NEW FUNCTION: Multiple params, RETURNS TABLE, plpgsql
         Function(
@@ -37,7 +37,7 @@ class Base(_Base):  # type: ignore
             parameters=["group_ids integer[]"],
             returns=FunctionReturn(table=["id integer", "name text"]),
             language="plpgsql",  # Requires plpgsql
-            volatility=FunctionVolatility.STABLE,
+            volatility=FunctionVolatility.stable,
         ),
     )
 

sqlalchemy_declarative_extensions-0.17.0/tests/examples/test_trigger_table_args/models.py

@@ -0,0 +1,24 @@
+from sqlalchemy import Column, types
+
+from sqlalchemy_declarative_extensions import declarative_database
+from sqlalchemy_declarative_extensions.dialects.postgresql import Trigger
+from sqlalchemy_declarative_extensions.sqlalchemy import declarative_base
+
+_Base = declarative_base()
+
+
+@declarative_database
+class Base(_Base):  # type: ignore
+    __abstract__ = True
+
+
+class Foo(Base):
+    __tablename__ = "foo"
+    __table_args__ = (
+        Trigger.after("insert", execute="gimme")
+        .named("on_insert_foo")
+        .when("pg_trigger_depth() < 1")
+        .for_each_row(),
+    )
+
+    id = Column(types.Integer(), primary_key=True)

sqlalchemy_declarative_extensions-0.17.0/tests/examples/test_trigger_table_args/test_migrations.py

@@ -0,0 +1,41 @@
+import pytest
+from pytest_alembic import MigrationContext
+from pytest_mock_resources import PostgresConfig, create_postgres_fixture
+from sqlalchemy import text
+
+alembic_engine = create_postgres_fixture(scope="function", engine_kwargs={"echo": True})
+
+
+@pytest.fixture(scope="session")
+def pmr_postgres_config():
+    return PostgresConfig(image="postgres:13", port=None, ci_port=None)
+
+
+def test_apply_autogenerated_revision(alembic_runner: MigrationContext, alembic_engine):
+    with alembic_engine.connect() as conn:
+        with conn.begin() as trans:
+            conn.execute(
+                text(
+                    """
+                    CREATE FUNCTION gimme() RETURNS trigger LANGUAGE plpgsql AS $$
+                    BEGIN
+                    INSERT INTO foo (id) select NEW.id + 1;
+                    RETURN NULL;
+                    END
+                    $$;
+                    """
+                )
+            )
+            trans.commit()
+
+    alembic_runner.migrate_up_one()
+    result = alembic_runner.generate_revision(
+        autogenerate=True, prevent_file_generation=False
+    )
+    alembic_runner.migrate_up_one()
+
+    with alembic_engine.connect() as conn:
+        conn.execute(text("insert into foo (id) values (1)"))
+        result = [r for r, *_ in conn.execute(text("select id from foo")).fetchall()]
+
+    assert result == [1, 2]