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

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/.github/workflows/test.yml

@@ -18,9 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # Test our minimum version bound, the highest version available,
-        # and something in the middle (i.e. what gets run locally).
-        python-version: ["3.8", "3.10", "3.11", "3.12"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
         sqlalchemy-version: ["1.3.0", "1.4.0", "2.0.0"]
         postgres-drivername: ["postgresql+psycopg2", "postgresql+psycopg"]
         exclude:
@@ -36,6 +34,7 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
           architecture: x64
 
       - name: Set up uv

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

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.19
+
+### 0.19.0
+
+- feat: Accept a `Function` as a trigger's `execute`, creating it alongside the trigger.
+
+## 0.18
+
+
+### 0.18.0
+
+- chore: Drop official support for python 3.8/3.9. In this release code is not
+  changed which breaks support, but it's no longer being tested and so will likely
+  break once we start adopting newer syntax features.
+- feat: Accept plain strings for every enum-valued option.
+- feat: Add `Views(include=[...])`, mirroring `Functions`/`Triggers`.
+- feat: Add `Procedures(include=[...])`, mirroring `Functions`/`Triggers`/`Views`.
+- fix: (Snowflake) Skip views whose definition is NULL (inaccessible to the current role).
+
 ## 0.17
 
 ### 0.17.0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlalchemy-declarative-extensions
-Version: 0.17.0
+Version: 0.19.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/
@@ -211,7 +211,7 @@ License:                                  Apache License
 License-File: LICENSE
 Keywords: alembic,declarative,function,grant,mysql,postgresql,role,schema,snowflake,sqlalchemy,sqlite,trigger,view
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <4,>=3.8
+Requires-Python: <4,>=3.10
 Requires-Dist: sqlalchemy>=1.3
 Provides-Extra: alembic
 Requires-Dist: alembic>=1.0; extra == 'alembic'

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/docs/source/triggers.md

@@ -91,6 +91,61 @@ the natural ordering, but it does mean that doing so afterwards will discard any
 already-attached table-level triggers.
 ```
 
+## Executing a function
+
+For dialects whose triggers execute a function (PostgreSQL), `execute` may be a
+`Function` rather than the name of one. The function is then created automatically
+alongside the trigger, so it need not be separately registered through `Functions`.
+
+```python
+from sqlalchemy_declarative_extensions.dialects.postgresql import Trigger, trigger_function
+
+audit = trigger_function(
+    "audit",
+    """
+    BEGIN
+    INSERT INTO log (message) VALUES (TG_TABLE_NAME);
+    RETURN NULL;
+    END
+    """,
+)
+
+
+class Foo(Base):
+    __tablename__ = "foo"
+    __table_args__ = (
+        Trigger.after("insert", execute=audit).named("on_insert_foo").for_each_row(),
+    )
+
+    id = Column(types.Integer(), primary_key=True)
+```
+
+This works however the trigger is declared (`Triggers`, `register_trigger` or
+`__table_args__`). Any number of triggers may share the same function, as with the generic
+audit function above, and it is created once. Declaring two *different* functions with the
+same qualified name is an error.
+
+`trigger_function` returns a PostgreSQL `Function` fixed to `RETURNS trigger LANGUAGE plpgsql`,
+and accepts neither `parameters` nor `returns`. A plain `Function` may be used in the
+same way when more control is needed.
+
+```{note}
+Trigger functions are collected when `register_sqlalchemy_events` is called, so call it
+after the models which declare triggers.
+```
+
+```{note}
+When a function is only declared through a trigger, only that function is managed:
+other functions in the database are left alone. If you also declare `Functions`, its
+`ignore_unspecified` and `include`/`ignore` settings apply to the combined set (with
+trigger functions added to `include`, if set).
+```
+
+```{note}
+MySQL triggers execute a raw statement, so passing a `Function` to a MySQL `Trigger`
+raises a `TypeError`.
+```
+
 ```{eval-rst}
 .. autoapimodule:: sqlalchemy_declarative_extensions.trigger.base
    :members: Trigger, Triggers, register_trigger

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/docs/source/views.md

@@ -98,6 +98,22 @@ allows you to avoid duplicating the list of columns unnecessarily.
 Finally, you can directly call `register_view` to imperitively register a normal
 `View` object, if the class interface doesn't float your boat.
 
+## Managing a subset of a shared database
+
+Autogenerate drops any existing view that is not declared. When the database is
+shared with other metadata, `include` limits the comparison to existing views
+matching one of its globs (matched against the schema-qualified name):
+
+```python
+views = Views(include=["foo.*"]).are(...)
+```
+
+Views in `foo` are created, updated, and dropped when no longer declared, while
+every other view is left alone, including views added to the database later.
+Declared views are always compared, even when they fall outside of `include`.
+`ignore` still applies on top of `include`, and `ignore_unspecified` remains the
+blunter option which suppresses all drops.
+
 ## Materialized views
 
 Materialized views can be created by adding the `materialized=True` kwarg to the

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

@@ -1,6 +1,6 @@
 [project]
 name = "sqlalchemy-declarative-extensions"
-version = "0.17.0"
+version = "0.19.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" }
@@ -25,7 +25,7 @@ keywords = [
 ]
 classifiers = ["Topic :: Software Development :: Libraries :: Python Modules"]
 
-requires-python = ">=3.8,<4"
+requires-python = ">=3.10,<4"
 
 dependencies = ["sqlalchemy >= 1.3"]
 
@@ -54,15 +54,12 @@ dev = [
     "psycopg[binary]",
     "psycopg2-binary",
 
-    # snowflake
-    "fakesnow >= 0.9.21; python_version >= '3.9'",
-    "snowflake-connector-python >= 3.7; python_version >= '3.9'",
-    "snowflake-sqlalchemy >= 1.6.0; python_version >= '3.9'",
+    # snowflake (fakesnow>=0.12 requires python 3.11+)
+    "fakesnow >= 0.9.21; python_version >= '3.11'",
+    "snowflake-connector-python >= 3.7; python_version >= '3.11'",
+    "snowflake-sqlalchemy >= 1.6.0; python_version >= '3.11'",
 ]
 
-[tool.uv]
-environments = ["python_version < '3.9'", "python_version >= '3.9' and python_version < '4'"]
-
 [tool.mypy]
 strict_optional = true
 ignore_missing_imports = true
@@ -94,6 +91,7 @@ filterwarnings = [
     'ignore:`ignore_views` is deprecated, use `ignore` instead:DeprecationWarning',
     'ignore:The GenericFunction.*:sqlalchemy.exc.SAWarning',
     'ignore:Did not recognize type.*:sqlalchemy.exc.SAWarning',
+    'ignore:Arrow output on a DB-API result.*:UserWarning',
 ]
 pytester_example_dir = "tests/examples"
 markers = ['grant', 'schema', 'role', 'row', 'alembic']

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/src/sqlalchemy_declarative_extensions/api.py

@@ -229,7 +229,7 @@ def register_create_events(
     concrete_grants = metadata.info.get("grants") or Grants()
     concrete_views = Views.extract(metadata) or Views()
     concrete_procedures = metadata.info.get("procedures") or Procedures()
-    concrete_functions = metadata.info.get("functions") or Functions()
+    concrete_functions = Functions.extract(metadata) or Functions()
     concrete_triggers = metadata.info.get("triggers") or Triggers()
     concrete_databases = metadata.info.get("databases") or Databases()
     concrete_rows = metadata.info.get("rows") or Rows()
@@ -333,7 +333,7 @@ def register_drop_events(
     concrete_roles = metadata.info.get("roles")
     concrete_views = metadata.info.get("views")
     concrete_procedures = metadata.info.get("procedures")
-    concrete_functions = metadata.info.get("functions")
+    concrete_functions = Functions.extract(metadata)
     concrete_triggers = metadata.info.get("triggers")
     concrete_databases = metadata.info.get("databases")
 

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/src/sqlalchemy_declarative_extensions/dialects/mysql/function.py

@@ -6,17 +6,18 @@ from dataclasses import dataclass, replace
 
 from typing_extensions import Self
 
+from sqlalchemy_declarative_extensions.dialects.from_string import FromStrings
 from sqlalchemy_declarative_extensions.function import base
 
 
 @enum.unique
-class FunctionSecurity(enum.Enum):
+class FunctionSecurity(FromStrings):
     invoker = "INVOKER"
     definer = "DEFINER"
 
 
 @enum.unique
-class FunctionDataAccess(enum.Enum):
+class FunctionDataAccess(FromStrings):
     no_sql = "NO SQL"
     contains_sql = "CONTAINS SQL"
     reads_sql = "READS SQL DATA"
@@ -31,6 +32,10 @@ class Function(base.Function):
     deterministic: bool = False
     data_access: FunctionDataAccess = FunctionDataAccess.contains_sql
 
+    def __post_init__(self):
+        self.security = FunctionSecurity.from_string(self.security)
+        self.data_access = FunctionDataAccess.from_string(self.data_access)
+
     @classmethod
     def from_unknown_function(cls, f: base.Function) -> Self:
         if isinstance(f, cls):
@@ -70,14 +75,14 @@ class Function(base.Function):
     def to_sql_drop(self) -> list[str]:
         return [f"DROP FUNCTION {self.qualified_name};"]
 
-    def with_security(self, security: FunctionSecurity):
-        return replace(self, security=security)
+    def with_security(self, security: FunctionSecurity | str):
+        return replace(self, security=FunctionSecurity.from_string(security))
 
     def with_security_definer(self):
         return replace(self, security=FunctionSecurity.definer)
 
-    def with_data_access(self, data_access: FunctionDataAccess):
-        return replace(self, data_access=data_access)
+    def with_data_access(self, data_access: FunctionDataAccess | str):
+        return replace(self, data_access=FunctionDataAccess.from_string(data_access))
 
     def no_sql(self):
         return self.with_data_access(FunctionDataAccess.no_sql)

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/src/sqlalchemy_declarative_extensions/dialects/mysql/procedure.py

@@ -6,11 +6,12 @@ from dataclasses import dataclass, replace
 
 from typing_extensions import Self
 
+from sqlalchemy_declarative_extensions.dialects.from_string import FromStrings
 from sqlalchemy_declarative_extensions.procedure import base
 
 
 @enum.unique
-class ProcedureSecurity(enum.Enum):
+class ProcedureSecurity(FromStrings):
     invoker = "INVOKER"
     definer = "DEFINER"
 
@@ -21,6 +22,9 @@ class Procedure(base.Procedure):
 
     security: ProcedureSecurity = ProcedureSecurity.definer
 
+    def __post_init__(self):
+        self.security = ProcedureSecurity.from_string(self.security)
+
     @classmethod
     def from_unknown_procedure(cls, f: base.Procedure) -> Self:
         if isinstance(f, cls):
@@ -32,8 +36,8 @@ class Procedure(base.Procedure):
             schema=f.schema,
         )
 
-    def with_security(self, security: ProcedureSecurity):
-        return replace(self, security=security)
+    def with_security(self, security: ProcedureSecurity | str):
+        return replace(self, security=ProcedureSecurity.from_string(security))
 
     def with_security_definer(self):
         return replace(self, security=ProcedureSecurity.definer)

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/src/sqlalchemy_declarative_extensions/dialects/mysql/query.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
 
 from sqlalchemy.engine import Connection
 
@@ -27,12 +27,17 @@ from sqlalchemy_declarative_extensions.dialects.mysql.trigger import (
 )
 from sqlalchemy_declarative_extensions.function import Function as BaseFunction
 from sqlalchemy_declarative_extensions.procedure import Procedure as BaseProcedure
+from sqlalchemy_declarative_extensions.sql import filter_ignored
 from sqlalchemy_declarative_extensions.view.base import View
 
 
-def get_views_mysql(connection: Connection):
+def get_views_mysql(
+    connection: Connection,
+    ignore: Iterable[str] = (),
+    include: Iterable[str] | None = None,
+):
     current_database = connection.engine.url.database
-    return [
+    views = [
         View(
             v.name,
             v.definition,
@@ -40,6 +45,7 @@ def get_views_mysql(connection: Connection):
         )
         for v in connection.execute(views_query).fetchall()
     ]
+    return filter_ignored(views, ignore, include=include)
 
 
 def get_triggers_mysql(connection: Connection) -> list[Trigger]:

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

@@ -32,6 +32,9 @@ class TriggerOrder:
     order: TriggerOrders
     other_trigger_name: str
 
+    def __post_init__(self):
+        self.order = TriggerOrders.from_string(self.order)
+
 
 @dataclass
 class Trigger(base.Trigger):
@@ -44,6 +47,15 @@ class Trigger(base.Trigger):
     event: TriggerEvents
     order: TriggerOrder | None = None
 
+    def __post_init__(self):
+        if not isinstance(self.execute, str):
+            raise TypeError(
+                f"MySQL trigger '{self.name}' must execute a statement string,"
+                " not a `Function`."
+            )
+        self.time = TriggerTimes.from_string(self.time)
+        self.event = TriggerEvents.from_string(self.event)
+
     @classmethod
     def before(
         cls,
@@ -111,6 +123,7 @@ class Trigger(base.Trigger):
         if self.order:
             components.append(self.order.order.value)
             components.append(self.order.other_trigger_name)
+        assert isinstance(self.execute, str)
         components.append(self.execute)
 
         return " ".join(components) + ";"

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

@@ -5,6 +5,7 @@ from sqlalchemy_declarative_extensions.dialects.postgresql.function import (
     FunctionReturn,
     FunctionSecurity,
     FunctionVolatility,
+    trigger_function,
 )
 from sqlalchemy_declarative_extensions.dialects.postgresql.grant import (
     DefaultGrant,
@@ -70,4 +71,5 @@ __all__ = [
     "TypeGrants",
     "View",
     "ViewIndex",
+    "trigger_function",
 ]

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

@@ -8,6 +8,7 @@ from typing import Any, List, Literal, Sequence, Tuple, cast
 
 from sqlalchemy import Column
 
+from sqlalchemy_declarative_extensions.dialects.from_string import FromStrings
 from sqlalchemy_declarative_extensions.function import base
 from sqlalchemy_declarative_extensions.sql import quote_name
 
@@ -29,12 +30,12 @@ END
 
 
 @enum.unique
-class FunctionSecurity(enum.Enum):
+class FunctionSecurity(FromStrings):
     invoker = "INVOKER"
     definer = "DEFINER"
 
 
-class FunctionVolatility(enum.Enum):
+class FunctionVolatility(FromStrings):
     volatile = "VOLATILE"
     stable = "STABLE"
     immutable = "IMMUTABLE"
@@ -44,7 +45,7 @@ class FunctionVolatility(enum.Enum):
     IMMUTABLE = immutable
 
 
-class FunctionParallel(enum.Enum):
+class FunctionParallel(FromStrings):
     unsafe = "UNSAFE"
     restricted = "RESTRICTED"
     safe = "SAFE"
@@ -69,6 +70,11 @@ class Function(base.Function):
     strict: bool = False
     leakproof: bool = False
 
+    def __post_init__(self):
+        self.security = FunctionSecurity.from_string(self.security)
+        self.volatility = FunctionVolatility.from_string(self.volatility)
+        self.parallel = FunctionParallel.from_string(self.parallel)
+
     @property
     def _has_sqlbody(self) -> bool:
         return self.language.lower() == "sql" and bool(
@@ -128,12 +134,18 @@ class Function(base.Function):
 
         return [f"DROP FUNCTION {self.qualified_name}({param_str});"]
 
-    def with_security(self, security: FunctionSecurity):
-        return replace(self, security=security)
+    def with_security(self, security: FunctionSecurity | str):
+        return replace(self, security=FunctionSecurity.from_string(security))
 
     def with_security_definer(self):
         return replace(self, security=FunctionSecurity.definer)
 
+    def with_volatility(self, volatility: FunctionVolatility | str):
+        return replace(self, volatility=FunctionVolatility.from_string(volatility))
+
+    def with_parallel(self, parallel: FunctionParallel | str):
+        return replace(self, parallel=FunctionParallel.from_string(parallel))
+
     def normalize(self) -> Function:
         definition = textwrap.dedent(self.definition)
         if self._has_sqlbody:
@@ -351,3 +363,21 @@ type_map = {
     "bool[]": "_bool",
     "boolean[]": "_bool",
 }
+
+
+def trigger_function(
+    name: str,
+    definition: str,
+    *,
+    schema: str | None = None,
+    security: FunctionSecurity = FunctionSecurity.invoker,
+) -> Function:
+    """Create a plpgsql `Function` returning `trigger`, suitable for `Trigger(execute=...)`."""
+    return Function(
+        name=name,
+        definition=definition,
+        schema=schema,
+        security=security,
+        returns="trigger",
+        language="plpgsql",
+    )

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/src/sqlalchemy_declarative_extensions/dialects/postgresql/procedure.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass, replace
 
 from typing_extensions import Self
 
+from sqlalchemy_declarative_extensions.dialects.from_string import FromStrings
 from sqlalchemy_declarative_extensions.procedure import base
 from sqlalchemy_declarative_extensions.sql import quote_name
 
@@ -24,7 +25,7 @@ END
 
 
 @enum.unique
-class ProcedureSecurity(enum.Enum):
+class ProcedureSecurity(FromStrings):
     invoker = "INVOKER"
     definer = "DEFINER"
 
@@ -40,6 +41,9 @@ class Procedure(base.Procedure):
 
     security: ProcedureSecurity = ProcedureSecurity.invoker
 
+    def __post_init__(self):
+        self.security = ProcedureSecurity.from_string(self.security)
+
     @property
     def _has_sqlbody(self) -> bool:
         return self.language.lower() == "sql" and bool(
@@ -75,8 +79,8 @@ class Procedure(base.Procedure):
             definition = definition.strip()
         return replace(self, definition=definition)
 
-    def with_security(self, security: ProcedureSecurity):
-        return replace(self, security=security)
+    def with_security(self, security: ProcedureSecurity | str):
+        return replace(self, security=ProcedureSecurity.from_string(security))
 
     def with_security_definer(self):
         return replace(self, security=ProcedureSecurity.definer)

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

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
 from itertools import zip_longest
 from typing import Container, List, cast
 
@@ -50,7 +50,7 @@ from sqlalchemy_declarative_extensions.dialects.postgresql.view import (
 )
 from sqlalchemy_declarative_extensions.function import Function as BaseFunction
 from sqlalchemy_declarative_extensions.procedure import Procedure as BaseProcedure
-from sqlalchemy_declarative_extensions.sql import qualify_name
+from sqlalchemy_declarative_extensions.sql import is_ignored, qualify_name
 
 EXTENSION_SCHEMAS = {
     "postgis_topology": ["topology"],
@@ -175,11 +175,19 @@ def get_roles_postgresql(connection: Connection, exclude=None):
     return result
 
 
-def get_views_postgresql(connection: Connection):
+def get_views_postgresql(
+    connection: Connection,
+    ignore: Iterable[str] = (),
+    include: Iterable[str] | None = None,
+):
     views = []
     for v in connection.execute(views_query).fetchall():
         schema = v.schema if v.schema != "public" else None
 
+        # Avoids the per-view index introspection for views which are ignored anyway.
+        if is_ignored(qualify_name(schema, v.name), ignore, include=include):
+            continue
+
         indexes: list[ViewIndex | Index | UniqueConstraint] = [
             ViewIndex(
                 name=raw["name"],

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

@@ -5,6 +5,7 @@ from dataclasses import dataclass, replace
 from sqlalchemy.engine import Connection
 
 from sqlalchemy_declarative_extensions.dialects.from_string import FromStrings
+from sqlalchemy_declarative_extensions.function.base import Function
 from sqlalchemy_declarative_extensions.sql import quote_name
 from sqlalchemy_declarative_extensions.trigger import base
 
@@ -94,13 +95,22 @@ class Trigger(base.Trigger):
     old_table: str | None = None
     new_table: str | None = None
 
+    def __post_init__(self):
+        self.events = TriggerEvents.from_strings(self.events)
+        self.time = TriggerTimes.from_string(self.time)
+        self.for_each = TriggerForEach.from_string(self.for_each)
+
     @property
     def identity(self) -> tuple[str, str]:
         return self.on, self.name
 
     @classmethod
     def before(
-        cls, *events: TriggerEvents | str, execute: str, on: str = "", name: str = ""
+        cls,
+        *events: TriggerEvents | str,
+        execute: str | Function,
+        on: str = "",
+        name: str = "",
     ):
         return cls(
             time=TriggerTimes.before,
@@ -112,7 +122,11 @@ class Trigger(base.Trigger):
 
     @classmethod
     def after(
-        cls, *events: TriggerEvents | str, execute: str, on: str = "", name: str = ""
+        cls,
+        *events: TriggerEvents | str,
+        execute: str | Function,
+        on: str = "",
+        name: str = "",
     ):
         return cls(
             time=TriggerTimes.after,
@@ -124,7 +138,11 @@ class Trigger(base.Trigger):
 
     @classmethod
     def instead_of(
-        cls, *events: TriggerEvents | str, execute: str, on: str = "", name: str = ""
+        cls,
+        *events: TriggerEvents | str,
+        execute: str | Function,
+        on: str = "",
+        name: str = "",
     ):
         return cls(
             time=TriggerTimes.instead_of,
@@ -198,7 +216,7 @@ class Trigger(base.Trigger):
         args_quoted = (
             tuple(f"'{arg}'" for arg in self.arguments) if self.arguments else ()
         )
-        components.append(quote_name(self.execute) + f"({','.join(args_quoted)})")
+        components.append(quote_name(self.execute_name) + f"({','.join(args_quoted)})")
         return " ".join(components) + ";"
 
     def to_sql_drop(self):

{sqlalchemy_declarative_extensions-0.17.0 → sqlalchemy_declarative_extensions-0.19.0}/src/sqlalchemy_declarative_extensions/dialects/snowflake/query.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+import warnings
+from collections.abc import Iterable
+
 from sqlalchemy import text
 from sqlalchemy.engine import Connection
 
 from sqlalchemy_declarative_extensions.dialects.snowflake import Role, View
+from sqlalchemy_declarative_extensions.sql import is_ignored, qualify_name
 
 
 def get_schemas_snowflake(connection: Connection):
@@ -69,7 +73,20 @@ def get_databases_snowflake(connection: Connection):
     }
 
 
-def get_views_snowflake(connection: Connection):
+def get_views_snowflake(
+    connection: Connection,
+    ignore: Iterable[str] = (),
+    include: Iterable[str] | None = None,
+):
+    """Fetch the views of the current database.
+
+    Views matching any of the `ignore` globs, or (when `include` is given) none of the
+    `include` globs, are never introspected, so (for example) views which the current
+    role cannot see the definition of, but which are excluded anyway, do not interfere.
+    """
+    ignore = list(ignore)
+    include = None if include is None else list(include)
+
     views_query = text(
         """
             SELECT table_schema AS schema, table_name AS name, view_definition AS definition
@@ -83,6 +100,23 @@ def get_views_snowflake(connection: Connection):
     for v in connection.execute(views_query).fetchall():
         schema = v.schema if v.schema != "public" else None
 
+        # Snowflake identifiers are case-insensitive unless quoted, and it reports them uppercase.
+        qualified_name = qualify_name(schema, v.name)
+        if is_ignored(qualified_name, ignore, include=include, case_sensitive=False):
+            continue
+
+        # `view_definition` is NULL for views the current role does not have access to. Since we
+        # cant do anything with them, we'll loudly skip them to avoid a confusing autogenerate result
+        # where it tries to edit those views.
+        if v.definition is None:
+            warnings.warn(
+                f"Skipping view '{qualified_name}': its definition is not visible to the"
+                " current role. Ignore it explicitly (`Views(ignore=[...])`), or leave it out of"
+                " `Views(include=[...])`, to silence this.",
+                stacklevel=2,
+            )
+            continue
+
         assert v.definition.startswith("CREATE VIEW")
         *_, definition = v.definition.split(" ", 4)