sqlalchemy-declarative-extensions 0.16.11__tar.gz → 0.18.0__tar.gz

{sqlalchemy_declarative_extensions-0.16.11 → sqlalchemy_declarative_extensions-0.18.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.16.11 → sqlalchemy_declarative_extensions-0.18.0}/CHANGELOG.md

@@ -1,7 +1,26 @@
 # Changelog
 
+## 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
 
+- 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

{sqlalchemy_declarative_extensions-0.16.11 → sqlalchemy_declarative_extensions-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlalchemy-declarative-extensions
-Version: 0.16.11
+Version: 0.18.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.18.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.11 → sqlalchemy_declarative_extensions-0.18.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.16.11 → sqlalchemy_declarative_extensions-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlalchemy-declarative-extensions"
-version = "0.16.11"
+version = "0.18.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.16.11 → sqlalchemy_declarative_extensions-0.18.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.16.11 → sqlalchemy_declarative_extensions-0.18.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.16.11 → sqlalchemy_declarative_extensions-0.18.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.16.11 → sqlalchemy_declarative_extensions-0.18.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,12 +47,17 @@ class Trigger(base.Trigger):
     event: TriggerEvents
     order: TriggerOrder | None = None
 
+    def __post_init__(self):
+        self.time = TriggerTimes.from_string(self.time)
+        self.event = TriggerEvents.from_string(self.event)
+
     @classmethod
     def before(
         cls,
         event: TriggerEvents | str,
-        on: str,
+        *,
         execute: str,
+        on: str = "",
         name: str = "",
     ):
         return cls(
@@ -64,8 +72,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.11 → sqlalchemy_declarative_extensions-0.18.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.11 → sqlalchemy_declarative_extensions-0.18.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,27 +30,29 @@ END
 
 
 @enum.unique
-class FunctionSecurity(enum.Enum):
+class FunctionSecurity(FromStrings):
     invoker = "INVOKER"
     definer = "DEFINER"
 
 
-@enum.unique
-class FunctionVolatility(enum.Enum):
-    VOLATILE = "VOLATILE"
-    STABLE = "STABLE"
-    IMMUTABLE = "IMMUTABLE"
+class FunctionVolatility(FromStrings):
+    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}")
+
+class FunctionParallel(FromStrings):
+    unsafe = "UNSAFE"
+    restricted = "RESTRICTED"
+    safe = "SAFE"
+
+    UNSAFE = unsafe
+    RESTRICTED = restricted
+    SAFE = safe
 
 
 @dataclass
@@ -62,7 +65,15 @@ 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
+
+    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:
@@ -91,9 +102,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)
@@ -114,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:

{sqlalchemy_declarative_extensions-0.16.11 → sqlalchemy_declarative_extensions-0.18.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.16.11 → sqlalchemy_declarative_extensions-0.18.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
 
@@ -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,
@@ -49,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"],
@@ -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
@@ -159,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"],
@@ -227,33 +251,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)