velocity-python 0.0.89__py3-none-any.whl → 0.0.92__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.89"
+__version__ = version = "0.0.92"
 
 from . import aws
 from . import db

velocity/db/servers/postgres/sql.py

@@ -12,10 +12,44 @@ from ..tablehelper import TableHelper
 from collections.abc import Mapping, Sequence
 
 
+# Configure TableHelper for PostgreSQL
 TableHelper.reserved = reserved_words
 TableHelper.operators = OPERATORS
 
 
+def _get_table_helper(tx, table):
+    """
+    Utility function to create a TableHelper instance.
+    Ensures consistent configuration across all SQL methods.
+    """
+    return TableHelper(tx, table)
+
+
+def _validate_table_name(table):
+    """Validate table name format."""
+    if not table or not isinstance(table, str):
+        raise ValueError("Table name must be a non-empty string")
+    # Add more validation as needed
+    return table.strip()
+
+
+def _handle_predicate_errors(predicates, operation="WHERE"):
+    """Process a list of predicates with error handling."""
+    sql_parts = []
+    vals = []
+    
+    for pred, val in predicates:
+        sql_parts.append(pred)
+        if val is None:
+            pass
+        elif isinstance(val, tuple):
+            vals.extend(val)
+        else:
+            vals.append(val)
+    
+    return sql_parts, vals
+
+
 system_fields = [
     "sys_id",
     "sys_created",
@@ -72,9 +106,17 @@ class SQL:
         lock=None,
         skip_locked=None,
     ):
-
+        """
+        Generate a PostgreSQL SELECT statement with proper table helper integration.
+        """
         if not table:
             raise ValueError("Table name is required.")
+            
+        # Validate pagination parameters
+        if start is not None and not isinstance(start, int):
+            raise ValueError("Start (OFFSET) must be an integer.")
+        if qty is not None and not isinstance(qty, int):
+            raise ValueError("Qty (FETCH) must be an integer.")
 
         sql_parts = {
             "SELECT": [],
@@ -88,8 +130,8 @@ class SQL:
         sql = []
         vals = []
 
-        # Assume these helpers and functions exist externally
-        th = TableHelper(tx, table)
+        # Create table helper instance
+        th = _get_table_helper(tx, table)
 
         # Handle columns and DISTINCT before aliasing
         if columns is None:
@@ -97,25 +139,28 @@ class SQL:
             columns = ["*"]
         elif isinstance(columns, str):
             columns = th.split_columns(columns)
-
-        if not isinstance(columns, Sequence):
-            raise Exception(
-                f"variable `columns` must be a sequence, but {type(columns)} was found"
+        elif not isinstance(columns, Sequence):
+            raise TypeError(
+                f"Columns must be a string, sequence, or None, but {type(columns)} was found"
             )
 
-        columns = [c.strip() for c in columns]  # Preserve original case
+        # Clean and validate columns
+        columns = [c.strip() for c in columns if c.strip()]  # Remove empty columns
+        if not columns:
+            raise ValueError("No valid columns specified")
+            
         distinct = False
 
-        if any(
-            "distinct" in c.lower() for c in columns
-        ):  # Check if "distinct" exists in any entry
+        # Check for DISTINCT keyword in any column
+        if any("distinct" in c.lower() for c in columns):
             distinct = True
             columns = [re.sub(r"(?i)\bdistinct\b", "", c).strip() for c in columns]
 
+        # Process column references
         processed_columns = []
         for col in columns:
-            processed_columns.append(
-                th.resolve_references(
+            try:
+                processed_col = th.resolve_references(
                     col,
                     options={
                         "alias_column": True,
@@ -123,40 +168,65 @@ class SQL:
                         "bypass_on_error": True,
                     },
                 )
-            )
+                processed_columns.append(processed_col)
+            except Exception as e:
+                raise ValueError(f"Error processing column '{col}': {e}")
 
         columns = processed_columns
 
-        # Handle WHERE conditions
+        # Handle WHERE conditions with better error handling
         if isinstance(where, Mapping):
             new_where = []
             for key, val in where.items():
-                new_where.append(th.make_predicate(key, val))
+                try:
+                    new_where.append(th.make_predicate(key, val))
+                except Exception as e:
+                    raise ValueError(f"Error processing WHERE condition '{key}': {e}")
             where = new_where
 
+        # Handle ORDER BY with improved validation
         new_orderby = []
         if isinstance(orderby, str):
             orderby = th.split_columns(orderby)
+            
         # Handle orderby references
-        if isinstance(orderby, (Sequence)):
+        if isinstance(orderby, Sequence):
             for column in orderby:
-                if " " in column:
-                    col_name, direction = column.split(" ", 1)
-                    col_name = th.resolve_references(
-                        col_name, options={"alias_only": True}
-                    )
-                    new_orderby.append(f"{col_name} {direction}")
-                else:
-                    new_orderby.append(
-                        th.resolve_references(
+                try:
+                    if " " in column:
+                        parts = column.split(" ", 1)
+                        if len(parts) == 2:
+                            col_name, direction = parts
+                            # Validate direction
+                            direction = direction.upper()
+                            if direction not in ("ASC", "DESC"):
+                                raise ValueError(f"Invalid ORDER BY direction: {direction}")
+                            col_name = th.resolve_references(
+                                col_name.strip(), options={"alias_only": True}
+                            )
+                            new_orderby.append(f"{col_name} {direction}")
+                        else:
+                            raise ValueError(f"Invalid ORDER BY format: {column}")
+                    else:
+                        resolved_col = th.resolve_references(
                             column.strip(), options={"alias_only": True}
                         )
-                    )
+                        new_orderby.append(resolved_col)
+                except Exception as e:
+                    raise ValueError(f"Error processing ORDER BY column '{column}': {e}")
 
-        if isinstance(orderby, Mapping):
+        elif isinstance(orderby, Mapping):
             for key, val in orderby.items():
-                parsed_key = th.resolve_references(key, options={"alias_only": True})
-                new_orderby.append(f"{parsed_key} {val}")
+                try:
+                    # Validate direction
+                    direction = str(val).upper()
+                    if direction not in ("ASC", "DESC"):
+                        raise ValueError(f"Invalid ORDER BY direction: {direction}")
+                    parsed_key = th.resolve_references(key, options={"alias_only": True})
+                    new_orderby.append(f"{parsed_key} {direction}")
+                except Exception as e:
+                    raise ValueError(f"Error processing ORDER BY key '{key}': {e}")
+                    
         orderby = new_orderby
 
         # Handle groupby
@@ -308,7 +378,7 @@ class SQL:
         if not isinstance(data, Mapping) or not data:
             raise ValueError("data must be a non-empty mapping of column-value pairs.")
 
-        th = TableHelper(tx, table)
+        th = _get_table_helper(tx, table)
         set_clauses = []
         vals = []
 
@@ -390,12 +460,15 @@ class SQL:
         """
         Generate an INSERT statement.
         """
-
+        # Create a temporary TableHelper instance for quoting
+        # Note: We pass None for tx since we only need quoting functionality
+        temp_helper = TableHelper(None, table)
+        
         keys = []
         vals_placeholders = []
         args = []
         for key, val in data.items():
-            keys.append(TableHelper.quote(key.lower()))
+            keys.append(temp_helper.quote(key.lower()))
             if isinstance(val, str) and len(val) > 2 and val[:2] == "@@" and val[2:]:
                 vals_placeholders.append(val[2:])
             else:
@@ -404,7 +477,7 @@ class SQL:
 
         sql_parts = []
         sql_parts.append("INSERT INTO")
-        sql_parts.append(TableHelper.quote(table))
+        sql_parts.append(temp_helper.quote(table))
         sql_parts.append("(")
         sql_parts.append(",".join(keys))
         sql_parts.append(")")