starting parameters

3nids · 3nids · commit e0c312102af8 · 2025-04-17T16:40:04.000+02:00
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: "/requirements"
+    schedule:
+      interval: monthly
+      time: "04:00"
+      timezone: Europe/Paris
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
diff --git a/pum/schema_migrations.py b/pum/schema_migrations.py
@@ -7,6 +7,7 @@
 in the database.
 """
 
+import json
 import logging
 import re
 
@@ -54,11 +55,11 @@ def exists(self, conn: Connection) -> bool:
         query = sql.SQL(
             """
             SELECT EXISTS (
-                SELECT 1
-                FROM information_schema.tables
-                WHERE table_name = {table} AND table_schema = {schema}
-            )
-        """
+            SELECT 1
+            FROM information_schema.tables
+            WHERE table_name = {table} AND table_schema = {schema}
+            );
+            """
         ).format(
             schema=sql.Literal(schema),
             table=sql.Literal(table),
@@ -67,33 +68,6 @@ def exists(self, conn: Connection) -> bool:
         cursor = execute_sql(conn, query)
         return cursor.fetchone()[0]
 
-    def installed_modules(self, conn: Connection) -> list[tuple[str, str]]:
-        """
-        Returns the installed modules and their versions from the schema_migrations table.
-        Args:
-            conn (Connection): The database connection to fetch the installed modules and versions.
-        Returns:
-            list[tuple[str, str]]: A list of tuples containing the module name and version.
-        """
-        query = sql.SQL(
-            """
-            SELECT module, version
-            FROM (
-            SELECT module, version,
-                   ROW_NUMBER() OVER (PARTITION BY module ORDER BY date_installed DESC) AS rn
-            FROM {schema_migrations_table}
-            ) t
-            WHERE t.rn = 1;
-            """
-        ).format(
-            schema_migrations_table=sql.Identifier(
-                *self.config.schema_migrations_table.split(".")
-            )
-        )
-        cursor = conn.cursor()
-        cursor.execute(query)
-        return cursor.fetchall()
-
     def create(self, conn: Connection, commit: bool = True):
         """
         Creates the schema_migrations information table
@@ -115,6 +89,7 @@ def create(self, conn: Connection, commit: bool = True):
             version character varying(50) NOT NULL,
             beta_testing boolean NOT NULL DEFAULT false,
             changelog_files text[],
+            parameters jsonb,
             migration_table_version character varying(50) NOT NULL DEFAULT {version}
             );
         """
@@ -147,6 +122,8 @@ def set_baseline(
         version: Version | str,
         beta_testing: bool = False,
         commit: bool = True,
+        changelog_files: list[str] = None,
+        parameters: dict = None,
     ):
         """
         Sets the baseline into the migration table
@@ -170,13 +147,17 @@ def set_baseline(
         query = sql.SQL(
             """
             INSERT INTO {schema_migrations_table} (
-                version,
-                beta_testing,
-                migration_table_version
+            version,
+            beta_testing,
+            migration_table_version,
+            changelog_files,
+            parameters
             ) VALUES (
-                {version},
-                {beta_testing},
-                {migration_table_version}
+            {version},
+            {beta_testing},
+            {migration_table_version},
+            {changelog_files},
+            {parameters}
             )
         """
         ).format(
@@ -186,10 +167,89 @@ def set_baseline(
             schema_migrations_table=sql.Identifier(
                 *self.config.schema_migrations_table.split(".")
             ),
+            changelog_files=sql.Literal(changelog_files or []),
+            parameters=sql.Literal(json.dumps(parameters or {})),
         )
         logger.info(
             f"Setting baseline version {version} in {self.config.schema_migrations_table}"
         )
         conn.execute(query)
         if commit:
             conn.commit()
+
+    def baseline(self, conn: Connection) -> str:
+        """
+        Returns the baseline version from the migration table
+        Args:
+            conn: Connection
+                The database connection to get the baseline version.
+        Returns:
+            str: The baseline version.
+        """
+        query = sql.SQL(
+            """
+            SELECT version
+            FROM {schema_migrations_table}
+            WHERE id = (
+                SELECT id
+                FROM {schema_migrations_table}
+                ORDER BY date_installed DESC
+                LIMIT 1
+            )
+        """
+        ).format(
+            schema_migrations_table=sql.Identifier(
+                *self.config.schema_migrations_table.split(".")
+            )
+        )
+        cursor = execute_sql(conn, query)
+        return cursor.fetchone()[0]
+
+    def migration_details(self, conn: Connection, version: str = None) -> dict:
+        """
+        Returns the migration details from the migration table
+        Args:
+            conn: Connection
+                The database connection to get the migration details.
+            version: str
+                The version of the migration to get details for. If None, last migration is returned.
+        Returns:
+            dict: The migration details.
+        """
+        query = None
+        if version is None:
+            query = sql.SQL(
+                """
+                SELECT *
+                FROM {schema_migrations_table}
+                WHERE id = (
+                        SELECT id
+                        FROM {schema_migrations_table}
+                        ORDER BY date_installed DESC
+                        LIMIT 1
+                    )
+                ORDER BY date_installed DESC
+            """
+            ).format(
+                schema_migrations_table=sql.Identifier(
+                    *self.config.schema_migrations_table.split(".")
+                ),
+            )
+        else:
+            query = sql.SQL(
+                """
+                SELECT *
+                FROM {schema_migrations_table}
+                WHERE version = {version}
+            """
+            ).format(
+                schema_migrations_table=sql.Identifier(
+                    *self.config.schema_migrations_table.split(".")
+                ),
+                version=sql.Literal(version),
+            )
+        cursor = execute_sql(conn, query)
+        row = cursor.fetchone()
+        if row is None:
+            return None
+        return dict(zip([desc[0] for desc in cursor.description], row))
diff --git a/pum/upgrader.py b/pum/upgrader.py
@@ -73,8 +73,18 @@ def __init__(
         self.schema_migrations = SchemaMigrations(self.config)
         self.dir = dir
 
-    def install(self):
-        """Installs the given module"""
+    def install(self, parameters: dict | None = None):
+        """
+        Installs the given module
+        This will create the schema_migrations table if it does not exist.
+        This will also apply all the changelogs that are after the current version.
+        The changelogs are applied in the order they are found in the directory.
+        It will also set the baseline version to the current version of the module.
+
+        args:
+            parameters: dict
+                The parameters to pass to the SQL files
+        """
 
         with psycopg.connect(f"service={self.pg_service}") as conn:
             if self.schema_migrations.exists(conn):
@@ -83,12 +93,17 @@ def install(self):
                 )
             self.schema_migrations.create(conn, commit=False)
             for changelog in self.changelogs(after_current_version=False):
-                self.__apply_changelog(conn, changelog, commit=False)
+                changelog_files = self.__apply_changelog(
+                    conn, changelog, commit=False, parameters=parameters
+                )
+                changelog_files = [str(f) for f in changelog_files]
                 self.schema_migrations.set_baseline(
                     conn=conn,
                     version=changelog.version,
                     beta_testing=False,
                     commit=False,
+                    changelog_files=changelog_files,
+                    parameters=parameters,
                 )
             logger
 
@@ -193,8 +208,12 @@ def changelog_files(self, changelog: str) -> list[Path]:
         return files
 
     def __apply_changelog(
-        self, conn: Connection, changelog: Changelog, commit: bool = True
-    ):
+        self,
+        conn: Connection,
+        changelog: Changelog,
+        parameters: dict | None = None,
+        commit: bool = True,
+    ) -> list[Path]:
         """
         Apply a changelog
         This will execute all the files in the changelog directory.
@@ -205,12 +224,19 @@ def __apply_changelog(
                 The connection to the database
             changelog: Changelog
                 The changelog to apply
+            parameters: dict
+                The parameters to pass to the SQL files
             commit: bool
                 If true, the transaction is committed. The default is true.
+
+        Returns:
+            list[Path]
+                The list of changelogs that were executed
         """
         files = self.changelog_files(changelog)
         for file in files:
-            execute_sql(conn=conn, sql=file, commit=commit)
+            execute_sql(conn=conn, sql=file, commit=commit, parameters=parameters)
+        return files
 
     def __run_delta_sql(self, delta):
         """Execute the delta sql file on the database"""
diff --git a/pum/utils/execute_sql.py b/pum/utils/execute_sql.py
@@ -10,29 +10,38 @@
 
 
 def execute_sql(
-    conn: Connection, sql: str | Path, params: tuple = (), commit: bool = False
+    conn: Connection,
+    sql: str | Path,
+    parameters: dict | None = None,
+    commit: bool = False,
 ) -> Cursor:
     """
     Execute a SQL statement with optional parameters.
 
     Args:
         conn (Connection): The database connection to execute the SQL statement.
         sql (str | Path): The SQL statement to execute or a path to a SQL file.
-        params (tuple, optional): Parameters to bind to the SQL statement. Defaults to ().
+        parameters (dict, optional): Parameters to bind to the SQL statement. Defaults to ().
         commit (bool, optional): Whether to commit the transaction. Defaults to False.
     Raises:
         RuntimeError: If the SQL execution fails.
     """
     cursor = conn.cursor()
     try:
-        sql_code = sql
         if isinstance(sql, Path):
             logger.debug(
                 f"Executing SQL from file: {sql}",
             )
             with open(sql) as file:
-                sql_code = file.read()
-        cursor.execute(sql_code, params)
+                sql_code = file.read().split(";")
+        else:
+            sql_code = [sql]
+
+        for statement in sql_code:
+            if parameters:
+                cursor.execute(statement, parameters)
+            else:
+                cursor.execute(statement)
     except SyntaxError as e:
         raise PumSqlException(
             f"SQL execution failed for the following code: {sql} {e}"
diff --git a/pyproject.toml b/pyproject.toml
@@ -43,10 +43,3 @@ enabled = true
 readme = {file = ["README.md"], content-type = "text/markdown"}
 dependencies = {file = ["requirements/base.txt"]}
 optional-dependencies.dev = {file = ["requirements/development.txt"]}
-
-[project.optional-dependencies]
-docs = [
-    "mkdocstrings[python]~=0.25",
-    "mkdocs-material>=9.5.17,<9.7.0",
-    "fancyboxmd~=1.1"
-]
diff --git a/test/data/parameters/.pum-config.yaml b/test/data/parameters/.pum-config.yaml
@@ -0,0 +1 @@
+changelogs_directory: my_delta_directory
diff --git a/test/data/parameters/changelogs/1.2.3/create_northwind.sql b/test/data/parameters/changelogs/1.2.3/create_northwind.sql
@@ -0,0 +1,8 @@
+CREATE SCHEMA IF NOT EXISTS pum_test_data;
+
+CREATE EXTENSION IF NOT EXISTS postgis;
+
+CREATE TABLE pum_test_data.some_table (
+    id INT PRIMARY KEY,
+    geom geometry(LineString, %(SRID)s)
+);
diff --git a/test/test_upgrader.py b/test/test_upgrader.py
@@ -47,7 +47,28 @@ def test_install_simple(self):
         )
         upgrader.install()
         self.assertTrue(sm.exists(self.conn))
-        self.assertEqual(sm.installed_modules(self.conn)[0][1], "1.2.3")
+        self.assertEqual(sm.baseline(self.conn), "1.2.3")
+        self.assertEqual(
+            sm.migration_details(self.conn), sm.migration_details(self.conn, "1.2.3")
+        )
+        self.assertEqual(sm.migration_details(self.conn)["version"], "1.2.3")
+        self.assertEqual(
+            sm.migration_details(self.conn)["changelog_files"],
+            ["test/data/simple/changelogs/1.2.3/create_northwind.sql"],
+        )
+
+    def test_parameters(self):
+        cfg = PumConfig()
+        sm = SchemaMigrations(cfg)
+        self.assertFalse(sm.exists(self.conn))
+        upgrader = Upgrader(
+            pg_service=self.pg_service,
+            config=cfg,
+            dir="test/data/parameters",
+        )
+        upgrader.install(parameters={"SRID": 2056})
+        self.assertTrue(sm.exists(self.conn))
+        self.assertEqual(sm.migration_details(self.conn)["parameters"], "{}")
 
     def test_install_custom_directory(self):
         cfg = PumConfig.from_yaml("test/data/custom_directory/.pum-config.yaml")

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+changelogs_directory: my_delta_directory`