velocity-python 0.0.131__py3-none-any.whl → 0.0.132__py3-none-any.whl

velocity/db/servers/postgres/__init__.py

@@ -1,10 +1,50 @@
 import os
 import psycopg2
 from .sql import SQL
+from ..base.initializer import BaseInitializer
 from velocity.db.core import engine
 
 
+class PostgreSQLInitializer(BaseInitializer):
+    """PostgreSQL database initializer."""
+
+    @staticmethod
+    def initialize(config=None, **kwargs):
+        """
+        Initialize PostgreSQL engine with psycopg2 driver.
+        
+        Args:
+            config: Configuration dictionary
+            **kwargs: Additional configuration parameters
+            
+        Returns:
+            Configured Engine instance
+        """
+        # Base configuration from environment
+        base_config = {
+            "database": os.environ.get("DBDatabase"),
+            "host": os.environ.get("DBHost"),
+            "port": os.environ.get("DBPort"),
+            "user": os.environ.get("DBUser"),
+            "password": os.environ.get("DBPassword"),
+        }
+        
+        # Remove None values
+        base_config = {k: v for k, v in base_config.items() if v is not None}
+        
+        # Merge configurations
+        final_config = PostgreSQLInitializer._merge_config(base_config, config, **kwargs)
+        
+        # Validate required configuration
+        required_keys = ["database", "host", "user", "password"]
+        PostgreSQLInitializer._validate_required_config(final_config, required_keys)
+        
+        return engine.Engine(psycopg2, final_config, SQL)
+
+
+# Maintain backward compatibility
 def initialize(config=None, **kwargs):
+    """Backward compatible initialization function - matches original behavior exactly."""
     konfig = {
         "database": os.environ["DBDatabase"],
         "host": os.environ["DBHost"],

velocity/db/servers/postgres/operators.py

@@ -1,3 +1,37 @@
+from ..base.operators import BaseOperators
+
+
+class PostgreSQLOperators(BaseOperators):
+    """
+    PostgreSQL-specific operator mappings.
+    """
+
+    @classmethod
+    def get_operators(cls):
+        """Returns PostgreSQL-specific operator mappings."""
+        return OPERATORS
+
+    @classmethod
+    def supports_case_insensitive_like(cls):
+        """PostgreSQL supports ILIKE for case-insensitive matching."""
+        return True
+
+    @classmethod
+    def supports_regex(cls):
+        """PostgreSQL supports regex operators."""
+        return True
+
+    @classmethod
+    def get_regex_operators(cls):
+        """Returns PostgreSQL regex operators."""
+        return {
+            "~": "~",
+            "!~": "!~",
+            "~*": "~*",
+            "!~*": "!~*",
+        }
+
+
 OPERATORS = {
     "<>": "<>",
     "!=": "<>",

velocity/db/servers/postgres/sql.py

@@ -4,10 +4,11 @@ import sqlparse
 from psycopg2 import sql as psycopg2_sql
 
 from velocity.db import exceptions
+from ..base.sql import BaseSQLDialect
 
 from .reserved import reserved_words
 from .types import TYPES
-from .operators import OPERATORS
+from .operators import OPERATORS, PostgreSQLOperators
 from ..tablehelper import TableHelper
 from collections.abc import Mapping, Sequence
 
@@ -61,7 +62,7 @@ system_fields = [
 ]
 
 
-class SQL:
+class SQL(BaseSQLDialect):
     server = "PostGreSQL"
     type_column_identifier = "data_type"
     is_nullable = "is_nullable"
@@ -95,7 +96,7 @@ class SQL:
     DataIntegrityErrorCodes = ["23503", "23502", "23514", "23P01", "22003"]
 
     @classmethod
-    def get_error(self, e):
+    def get_error(cls, e):
         error_code = getattr(e, "pgcode", None)
         error_mesg = getattr(e, "pgerror", None)
         return error_code, error_mesg

velocity/db/servers/postgres/types.py

@@ -1,10 +1,11 @@
 import decimal
 import datetime
+from ..base.types import BaseTypes
 
 
-class TYPES:
+class TYPES(BaseTypes):
     """
-    A simple mapping of Python types <-> SQL types (for PostgreSQL).
+    PostgreSQL-specific type mapping implementation.
     """
 
     TEXT = "TEXT"
@@ -107,3 +108,88 @@ class TYPES:
         if v == cls.DATETIME_TZ or v == cls.TIMESTAMP_TZ:
             return datetime.datetime
         raise Exception(f"Unmapped type {v}")
+
+    @classmethod
+    def get_type(cls, v):
+        """
+        Returns a suitable SQL type string for a Python value/object.
+        """
+        if isinstance(v, str) and v.startswith("@@"):
+            # e.g. @@CURRENT_TIMESTAMP => special usage
+            return v[2:] or cls.TEXT
+        if isinstance(v, str) or v is str:
+            return cls.TEXT
+        if isinstance(v, bool) or v is bool:
+            return cls.BOOLEAN
+        if isinstance(v, int) or v is int:
+            return cls.BIGINT
+        if isinstance(v, float) or v is float:
+            return f"{cls.NUMERIC}(19, 6)"
+        if isinstance(v, decimal.Decimal) or v is decimal.Decimal:
+            return f"{cls.NUMERIC}(19, 6)"
+        if isinstance(v, datetime.datetime) or v is datetime.datetime:
+            return cls.DATETIME
+        if isinstance(v, datetime.date) or v is datetime.date:
+            return cls.DATE
+        if isinstance(v, datetime.time) or v is datetime.time:
+            return cls.TIME
+        if isinstance(v, datetime.timedelta) or v is datetime.timedelta:
+            return cls.INTERVAL
+        if isinstance(v, bytes) or v is bytes:
+            return cls.BINARY
+        return cls.TEXT
+
+    @classmethod
+    def get_conv(cls, v):
+        """
+        Returns a base SQL type for expression usage (e.g. CAST).
+        """
+        if isinstance(v, str) and v.startswith("@@"):
+            return v[2:] or cls.TEXT
+        if isinstance(v, str) or v is str:
+            return cls.TEXT
+        if isinstance(v, bool) or v is bool:
+            return cls.BOOLEAN
+        if isinstance(v, int) or v is int:
+            return cls.BIGINT
+        if isinstance(v, float) or v is float:
+            return cls.NUMERIC
+        if isinstance(v, decimal.Decimal) or v is decimal.Decimal:
+            return cls.NUMERIC
+        if isinstance(v, datetime.datetime) or v is datetime.datetime:
+            return cls.DATETIME
+        if isinstance(v, datetime.date) or v is datetime.date:
+            return cls.DATE
+        if isinstance(v, datetime.time) or v is datetime.time:
+            return cls.TIME
+        if isinstance(v, datetime.timedelta) or v is datetime.timedelta:
+            return cls.INTERVAL
+        if isinstance(v, bytes) or v is bytes:
+            return cls.BINARY
+        return cls.TEXT
+
+    @classmethod
+    def py_type(cls, v):
+        """
+        Returns the Python type that corresponds to an SQL type string.
+        """
+        v = str(v).upper()
+        if v == cls.INTEGER or v == cls.SMALLINT or v == cls.BIGINT:
+            return int
+        if v == cls.NUMERIC:
+            return decimal.Decimal
+        if v == cls.TEXT:
+            return str
+        if v == cls.BOOLEAN:
+            return bool
+        if v == cls.DATE:
+            return datetime.date
+        if v == cls.TIME or v == cls.TIME_TZ:
+            return datetime.time
+        if v == cls.DATETIME or v == cls.TIMESTAMP:
+            return datetime.datetime
+        if v == cls.INTERVAL:
+            return datetime.timedelta
+        if v == cls.DATETIME_TZ or v == cls.TIMESTAMP_TZ:
+            return datetime.datetime
+        raise Exception(f"Unmapped type {v}")

velocity/db/servers/sqlite/__init__.py

@@ -0,0 +1,52 @@
+import os
+import sqlite3
+from ..base.initializer import BaseInitializer
+from velocity.db.core import engine
+from .sql import SQL
+
+
+class SQLiteInitializer(BaseInitializer):
+    """SQLite database initializer."""
+
+    @staticmethod
+    def initialize(config=None, **kwargs):
+        """
+        Initialize SQLite engine with sqlite3 driver.
+        
+        Args:
+            config: Configuration dictionary
+            **kwargs: Additional configuration parameters
+            
+        Returns:
+            Configured Engine instance
+        """
+        # Base configuration - SQLite is simpler
+        base_config = {
+            "database": os.environ.get("DBDatabase", ":memory:"),  # Default to in-memory
+        }
+        
+        # Remove None values
+        base_config = {k: v for k, v in base_config.items() if v is not None}
+        
+        # Set SQLite-specific defaults
+        sqlite_defaults = {
+            "check_same_thread": False,  # Allow usage from different threads
+            "timeout": 30.0,  # Connection timeout
+        }
+        
+        # Merge configurations: defaults < env < config < kwargs
+        final_config = sqlite_defaults.copy()
+        final_config.update(base_config)
+        final_config = SQLiteInitializer._merge_config(final_config, config, **kwargs)
+        
+        # Validate required configuration - only database path is required
+        required_keys = ["database"]
+        SQLiteInitializer._validate_required_config(final_config, required_keys)
+        
+        return engine.Engine(sqlite3, final_config, SQL)
+
+
+# Maintain backward compatibility
+def initialize(config=None, **kwargs):
+    """Backward compatible initialization function."""
+    return SQLiteInitializer.initialize(config, **kwargs)

velocity/db/servers/sqlite/operators.py

@@ -0,0 +1,52 @@
+from ..base.operators import BaseOperators
+
+
+class SQLiteOperators(BaseOperators):
+    """
+    SQLite-specific operator mappings.
+    """
+
+    @classmethod
+    def get_operators(cls):
+        """Returns SQLite-specific operator mappings."""
+        return OPERATORS
+
+    @classmethod
+    def supports_case_insensitive_like(cls):
+        """SQLite LIKE is case-insensitive by default."""
+        return True  # Sort of - depends on the text encoding
+
+    @classmethod
+    def supports_regex(cls):
+        """SQLite supports REGEXP if the REGEXP function is defined."""
+        return True  # But requires the REGEXP function to be defined
+
+    @classmethod
+    def get_regex_operators(cls):
+        """Returns SQLite regex operators."""
+        return {
+            "REGEXP": "REGEXP",
+            "GLOB": "GLOB",
+        }
+
+
+OPERATORS = {
+    "<>": "<>",
+    "!=": "<>",
+    "!><": "NOT BETWEEN",
+    ">!<": "NOT BETWEEN", 
+    "><": "BETWEEN",
+    "%%": "LIKE",  # SQLite LIKE is case-insensitive by default
+    "!%%": "NOT LIKE",
+    "==": "=",
+    "<=": "<=",
+    ">=": ">=",
+    "<": "<",
+    ">": ">",
+    "%": "LIKE",
+    "!%": "NOT LIKE",
+    "=": "=",
+    "!": "<>",
+    "REGEXP": "REGEXP",
+    "GLOB": "GLOB",
+}

velocity/db/servers/sqlite/reserved.py

@@ -0,0 +1,20 @@
+reserved_words = [
+    "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND",
+    "AS", "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN",
+    "BY", "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN",
+    "COMMIT", "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
+    "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
+    "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
+    "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
+    "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING",
+    "IF", "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY",
+    "INNER", "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL",
+    "JOIN", "KEY", "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO",
+    "NOT", "NOTNULL", "NULL", "OF", "OFFSET", "ON", "OR", "ORDER",
+    "OUTER", "PLAN", "PRAGMA", "PRIMARY", "QUERY", "RAISE", "RECURSIVE",
+    "REFERENCES", "REGEXP", "REINDEX", "RELEASE", "RENAME", "REPLACE",
+    "RESTRICT", "RIGHT", "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET",
+    "TABLE", "TEMP", "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER",
+    "UNION", "UNIQUE", "UPDATE", "USING", "VACUUM", "VALUES", "VIEW",
+    "VIRTUAL", "WHEN", "WHERE", "WITH", "WITHOUT"
+]