velocity-python 0.0.202__tar.gz → 0.0.204__tar.gz

{velocity_python-0.0.202 → velocity_python-0.0.204}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.202
+Version: 0.0.204
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.202 → velocity_python-0.0.204}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.202"
+version = "0.0.204"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.202 → velocity_python-0.0.204}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.202"
+__version__ = version = "0.0.204"
 
 from . import aws
 from . import db

{velocity_python-0.0.202 → velocity_python-0.0.204}/src/velocity/db/core/engine.py

@@ -1,5 +1,6 @@
 import inspect
 import re
+import time
 from contextlib import contextmanager
 from functools import wraps
 from velocity.db import exceptions
@@ -175,6 +176,7 @@ class Engine:
             else:
                 retry_count = 0
                 lock_timeout_count = 0
+                connection_retry_count = 0
                 while True:
                     try:
                         return function(*args, **kwds)
@@ -182,13 +184,35 @@ class Engine:
                         retry_count += 1
                         if retry_count > self.MAX_RETRIES:
                             raise
+                        # Back off a bit to reduce contention on hot DDL.
+                        time.sleep(min(2.0, 0.05 * (2**min(retry_count, 6))))
                         _tx.rollback()
                     except exceptions.DbLockTimeoutError:
                         lock_timeout_count += 1
                         if lock_timeout_count > self.MAX_RETRIES:
                             raise
+                        time.sleep(min(2.0, 0.05 * (2**min(lock_timeout_count, 6))))
                         _tx.rollback()
                         continue
+                    except exceptions.DbConnectionError as e:
+                        # Transient disconnects can happen during maintenance / restarts.
+                        # Retrying the entire top-level function is the safest option.
+                        msg = str(e).strip().lower()
+                        if not self._is_transient_connection_error_message(msg):
+                            raise
+
+                        connection_retry_count += 1
+                        if connection_retry_count > 6:
+                            raise
+
+                        # Force a reconnect on the next attempt.
+                        try:
+                            _tx.close()
+                        except Exception:
+                            _tx.connection = None
+
+                        time.sleep(min(2.0, 0.1 * (2**min(connection_retry_count, 5))))
+                        continue
                     except Exception:
                         raise
         finally:
@@ -442,6 +466,13 @@ class Engine:
             raise exceptions.DbObjectExistsError(enhanced_message) from exception
         if re.findall(r"server closed the connection unexpectedly", msg, re.M):
             raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"ssl syscall error: eof detected", msg, re.M):
+            raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"ssl syscall error: connection reset by peer", msg, re.M):
+            raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"eof detected", msg, re.M):
+            # Be conservative: EOFs typically indicate a transient disconnect.
+            raise exceptions.DbConnectionError(enhanced_message) from exception
         if re.findall(r"no connection to the server", msg, re.M):
             raise exceptions.DbConnectionError(enhanced_message) from exception
         if re.findall(r"connection timed out", msg, re.M):
@@ -450,6 +481,16 @@ class Engine:
             raise exceptions.DbConnectionError(enhanced_message) from exception
         if re.findall(r"cannot connect to server", msg, re.M):
             raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"terminating connection due to administrator command", msg, re.M):
+            raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"connection reset by peer", msg, re.M):
+            raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"broken pipe", msg, re.M):
+            raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"could not receive data from server", msg, re.M):
+            raise exceptions.DbConnectionError(enhanced_message) from exception
+        if re.findall(r"could not send data to server", msg, re.M):
+            raise exceptions.DbConnectionError(enhanced_message) from exception
         if re.findall(r"connection already closed", msg, re.M):
             raise exceptions.DbConnectionError(enhanced_message) from exception
         if re.findall(r"cursor already closed", msg, re.M):
@@ -471,6 +512,26 @@ class Engine:
         # If we can't classify it, re-raise with enhanced message
         raise type(exception)(enhanced_message) from exception
 
+    def _is_transient_connection_error_message(self, msg: str) -> bool:
+        """Return True if this looks like a retryable, transient connection drop.
+
+        Keep this intentionally conservative: authentication/config issues should not be retried.
+        """
+        needles = (
+            "ssl syscall error",
+            "eof detected",
+            "server closed the connection unexpectedly",
+            "connection reset by peer",
+            "broken pipe",
+            "could not receive data from server",
+            "could not send data to server",
+            "terminating connection due to administrator command",
+            "connection already closed",
+            "cursor already closed",
+            "no connection to the server",
+        )
+        return any(n in msg for n in needles)
+
     def _format_sql_with_params(self, sql, parameters):
         """
         Format SQL query with parameters merged for easy copy-paste debugging.

{velocity_python-0.0.202 → velocity_python-0.0.204}/src/velocity/db/core/transaction.py

@@ -2,6 +2,7 @@ import traceback
 
 from velocity.db.core.row import Row
 from velocity.db.core.table import Table
+from velocity.db.core.view import View
 from velocity.db.core.result import Result
 from velocity.db.core.column import Column
 from velocity.db.core.database import Database
@@ -47,6 +48,16 @@ class Transaction:
         """
         Retrieves a database cursor, opening a connection if necessary.
         """
+        # Lazily connect, and also recover if the driver reports a closed connection.
+        # (psycopg2 uses `connection.closed != 0` to indicate closed.)
+        if self.connection is not None:
+            try:
+                if getattr(self.connection, "closed", 0):
+                    self.connection = None
+            except Exception:
+                # If the driver object is in a bad state, force a reconnect.
+                self.connection = None
+
         if not self.connection:
             self.connection = self.engine.connect()
         if debug:
@@ -157,6 +168,10 @@ class Transaction:
         """
         return Table(self, tablename)
 
+    def view(self, viewname, schema=None):
+        """Returns a View helper for the given view name."""
+        return View(self, viewname, schema=schema)
+
     def sequence(self, name):
         """
         Returns a Sequence object for the given sequence name.

velocity_python-0.0.204/src/velocity/db/core/view.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from velocity.db import exceptions
+
+
+def _quote_ident(identifier: str) -> str:
+    return '"' + str(identifier).replace('"', '""') + '"'
+
+
+def _grantee_sql(grantee: str) -> str:
+    normalized = str(grantee).strip()
+    if not normalized:
+        raise ValueError("grantee cannot be empty")
+
+    keyword = normalized.upper()
+    if keyword in {"PUBLIC", "CURRENT_USER", "SESSION_USER"}:
+        return keyword
+
+    return _quote_ident(normalized)
+
+
+@dataclass
+class Grant:
+    privilege: str
+    grantee: str
+
+
+class View:
+    """PostgreSQL view helper.
+
+    This is intentionally lightweight and uses catalog queries directly rather than
+    embedding view DDL in the dialect.
+
+    Primary goals:
+    - Create views in an idempotent way (CREATE OR REPLACE).
+    - If the view already exists, "enhance" it by applying missing grants.
+
+    Notes:
+    - For updating the view definition, pass replace_existing=True.
+    - Privilege checks use has_table_privilege().
+    """
+
+    def __init__(self, tx, name: str, schema: str | None = None):
+        self.tx = tx
+        self.name = str(name).lower()
+        self.schema = (schema or getattr(tx.engine.sql, "default_schema", None) or "public").lower()
+
+    @property
+    def qualified_name(self) -> str:
+        return f"{_quote_ident(self.schema)}.{_quote_ident(self.name)}"
+
+    def exists(self) -> bool:
+        result = self.tx.execute(
+            """
+            SELECT 1
+            FROM information_schema.views
+            WHERE table_schema = %s AND table_name = %s
+            LIMIT 1
+            """,
+            [self.schema, self.name],
+        )
+        try:
+            rows = result.as_dict().all()
+        except Exception:
+            rows = []
+        return bool(rows)
+
+    def create_or_replace(self, select_sql: str) -> None:
+        if self.tx.engine.schema_locked:
+            raise exceptions.DbSchemaLockedError(
+                f"Cannot create/replace view {self.schema}.{self.name}: schema is locked"
+            )
+
+        sql = (select_sql or "").strip().rstrip(";")
+        if not sql:
+            raise ValueError("select_sql cannot be empty")
+
+        # If caller already provided CREATE VIEW, execute as-is.
+        lowered = sql.lower().lstrip()
+        if lowered.startswith("create"):
+            self.tx.execute(sql)
+            return
+
+        ddl = f"CREATE OR REPLACE VIEW {self.qualified_name} AS\n{sql}"
+        self.tx.execute(ddl)
+
+    def _has_privilege(self, grantee: str, privilege: str) -> bool:
+        # PUBLIC is a PostgreSQL pseudo-role for GRANT, but it's not necessarily a
+        # real role that can be passed to has_table_privilege() in all setups.
+        # GRANT itself is idempotent, so for PUBLIC we just apply it unconditionally.
+        if str(grantee).strip().upper() == "PUBLIC":
+            return False
+
+        # has_table_privilege(role, table, privilege)
+        # Note: privilege must be like 'SELECT'.
+        result = self.tx.execute(
+            "SELECT has_table_privilege(%s, %s, %s) as ok",
+            [grantee, f"{self.schema}.{self.name}", privilege],
+        )
+        try:
+            rows = result.as_dict().all()
+        except Exception:
+            rows = []
+        row = rows[0] if rows else None
+        return bool(row.get("ok")) if isinstance(row, dict) and row else False
+
+    def grant(self, privilege: str = "SELECT", grantee: str = "PUBLIC") -> None:
+        if self.tx.engine.schema_locked:
+            raise exceptions.DbSchemaLockedError(
+                f"Cannot grant privileges on {self.schema}.{self.name}: schema is locked"
+            )
+        privilege = str(privilege).upper().strip()
+        if not privilege:
+            raise ValueError("privilege cannot be empty")
+        self.tx.execute(
+            f"GRANT {privilege} ON {self.qualified_name} TO {_grantee_sql(grantee)}"
+        )
+
+    def ensure(
+        self,
+        select_sql: str | None = None,
+        *,
+        replace_existing: bool = False,
+        grants: list[Grant] | None = None,
+        grant_public_select: bool = True,
+    ) -> None:
+        """Ensure the view exists and has required grants.
+
+        - If the view does not exist, it is created using select_sql (required).
+        - If it exists, it is not modified unless replace_existing=True.
+        - Missing privileges are granted.
+        """
+
+        exists = self.exists()
+
+        if not exists:
+            if select_sql is None:
+                raise ValueError("select_sql is required when creating a missing view")
+            self.create_or_replace(select_sql)
+        elif replace_existing and select_sql is not None:
+            self.create_or_replace(select_sql)
+
+        desired_grants: list[Grant] = []
+        if grant_public_select:
+            desired_grants.append(Grant("SELECT", "PUBLIC"))
+        if grants:
+            desired_grants.extend(grants)
+
+        for g in desired_grants:
+            privilege = str(g.privilege).upper().strip()
+            grantee = str(g.grantee).strip()
+            if not privilege or not grantee:
+                continue
+
+            if not self._has_privilege(grantee, privilege):
+                self.grant(privilege=privilege, grantee=grantee)

{velocity_python-0.0.202 → velocity_python-0.0.204}/src/velocity/db/servers/postgres/sql.py

@@ -1412,14 +1412,14 @@ class SQL(BaseSQLDialect):
                     col_type = "TIMESTAMP"
                     sql.append(
                         f"ALTER TABLE {TableHelper.quote(table)} "
-                        f"ADD {TableHelper.quote(col_name_clean)} {col_type} {null_clause};"
+                        f"ADD COLUMN IF NOT EXISTS {TableHelper.quote(col_name_clean)} {col_type} {null_clause};"
                     )
                 else:
                     # Normal code path: rely on your `TYPES.get_type(...)` logic
                     col_type = TYPES.get_type(val)
                     sql.append(
                         f"ALTER TABLE {TableHelper.quote(table)} "
-                        f"ADD {TableHelper.quote(col_name_clean)} {col_type} {null_clause};"
+                        f"ADD COLUMN IF NOT EXISTS {TableHelper.quote(col_name_clean)} {col_type} {null_clause};"
                     )
 
         final_sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")

velocity_python-0.0.204/src/velocity/db/tests/test_view_helper.py

@@ -0,0 +1,97 @@
+import unittest
+from types import SimpleNamespace
+
+from velocity.db.core.view import View
+
+
+class FakeResult:
+    def __init__(self, rows):
+        self._rows = rows
+
+    def as_dict(self):
+        return self
+
+    def all(self):
+        return list(self._rows)
+
+
+class FakeTx:
+    def __init__(self):
+        self.executed = []
+        self.engine = SimpleNamespace(
+            schema_locked=False,
+            sql=SimpleNamespace(default_schema="public"),
+        )
+
+        # Toggleable responses
+        self._view_exists = False
+        self._has_priv = False
+
+    def execute(self, sql, parms=None, *args, **kwargs):
+        self.executed.append((sql, parms))
+
+        text = str(sql)
+        if "information_schema.views" in text:
+            return FakeResult([{"ok": True}]) if self._view_exists else FakeResult([])
+
+        if "has_table_privilege" in text:
+            return FakeResult([{"ok": bool(self._has_priv)}])
+
+        return FakeResult([])
+
+
+class TestViewHelper(unittest.TestCase):
+    def test_ensure_creates_missing_view_and_grants(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = False
+        tx._has_priv = False
+
+        v.ensure("select 1 as one")
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertIn("CREATE OR REPLACE VIEW", statements)
+        self.assertIn('"public"."my_view"', statements)
+        self.assertIn("GRANT SELECT ON", statements)
+
+    def test_ensure_existing_view_does_not_replace_by_default(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = True
+        tx._has_priv = False
+
+        v.ensure("select 1 as one")
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertNotIn("CREATE OR REPLACE VIEW", statements)
+        self.assertIn("GRANT SELECT ON", statements)
+
+    def test_ensure_existing_view_replaces_when_requested(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = True
+        tx._has_priv = True
+
+        v.ensure("select 1 as one", replace_existing=True)
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertIn("CREATE OR REPLACE VIEW", statements)
+
+    def test_ensure_skips_grant_if_already_present(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = True
+        tx._has_priv = True
+
+        v.ensure("select 1 as one")
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertNotIn("GRANT SELECT ON", statements)
+
+
+if __name__ == "__main__":
+    unittest.main()

{velocity_python-0.0.202 → velocity_python-0.0.204}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.202
+Version: 0.0.204
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.202 → velocity_python-0.0.204}/src/velocity_python.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ src/velocity/db/core/row.py
 src/velocity/db/core/sequence.py
 src/velocity/db/core/table.py
 src/velocity/db/core/transaction.py
+src/velocity/db/core/view.py
 src/velocity/db/servers/__init__.py
 src/velocity/db/servers/tablehelper.py
 src/velocity/db/servers/base/__init__.py
@@ -83,6 +84,7 @@ src/velocity/db/tests/test_schema_locking_initializers.py
 src/velocity/db/tests/test_schema_locking_simple.py
 src/velocity/db/tests/test_sql_builder.py
 src/velocity/db/tests/test_tablehelper.py
+src/velocity/db/tests/test_view_helper.py
 src/velocity/db/tests/postgres/__init__.py
 src/velocity/db/tests/postgres/common.py
 src/velocity/db/tests/postgres/test_column.py

{velocity_python-0.0.202 → velocity_python-0.0.204}/tests/test_table_alter.py

@@ -5,6 +5,7 @@ from velocity.db.core.table import Table
 from velocity.db.servers.postgres import types as postgres_types
 from velocity.db.servers.mysql import types as mysql_types
 from velocity.db.servers.sqlserver import types as sqlserver_types
+from velocity.db.servers.postgres.sql import SQL as PostgresSQL
 
 
 class RecordingSQL:
@@ -97,6 +98,10 @@ class FakeTable(Table):
 
 
 class TableAlterTests(unittest.TestCase):
+    def test_postgres_alter_add_is_idempotent(self):
+        sql, _vals = PostgresSQL.alter_add("aws_api_activity", {"user_id": str})
+        self.assertIn("ADD COLUMN IF NOT EXISTS", sql.upper())
+
     def test_postgres_type_change_uses_python_type(self):
         sql = RecordingSQL("PostGreSQL", postgres_types)
         table = FakeTable(