velocity-python 0.0.109__py3-none-any.whl → 0.0.161__py3-none-any.whl

velocity/db/servers/mysql/types.py

@@ -0,0 +1,107 @@
+import decimal
+import datetime
+from ..base.types import BaseTypes
+
+
+class TYPES(BaseTypes):
+    """
+    MySQL-specific type mapping implementation.
+    """
+
+    TEXT = "TEXT"
+    INTEGER = "INTEGER"
+    NUMERIC = "DECIMAL"
+    DATETIME = "DATETIME"
+    TIMESTAMP = "TIMESTAMP"
+    DATE = "DATE"
+    TIME = "TIME"
+    BIGINT = "BIGINT"
+    SMALLINT = "SMALLINT"
+    TINYINT = "TINYINT"
+    BOOLEAN = "BOOLEAN"
+    BINARY = "BLOB"
+    LONGTEXT = "LONGTEXT"
+    MEDIUMTEXT = "MEDIUMTEXT"
+    VARCHAR = "VARCHAR"
+
+    @classmethod
+    def get_type(cls, v):
+        """
+        Returns a suitable SQL type string for a Python value/object (MySQL).
+        """
+        is_special, special_val = cls._handle_special_values(v)
+        if is_special:
+            return special_val
+            
+        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, 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 (MySQL).
+        """
+        is_special, special_val = cls._handle_special_values(v)
+        if is_special:
+            return special_val
+            
+        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, 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 (MySQL).
+        """
+        v = str(v).upper()
+        if v in (cls.INTEGER, cls.SMALLINT, cls.BIGINT, cls.TINYINT):
+            return int
+        if v == cls.NUMERIC or "DECIMAL" in v:
+            return decimal.Decimal
+        if v in (cls.TEXT, cls.LONGTEXT, cls.MEDIUMTEXT, cls.VARCHAR) or "VARCHAR" in v or "CHAR" in v:
+            return str
+        if v == cls.BOOLEAN:
+            return bool
+        if v == cls.DATE:
+            return datetime.date
+        if v == cls.TIME:
+            return datetime.time
+        if v in (cls.DATETIME, cls.TIMESTAMP):
+            return datetime.datetime
+        if v == cls.BINARY or "BLOB" in v:
+            return bytes
+        raise Exception(f"Unmapped MySQL type {v}")

velocity/db/servers/postgres/__init__.py

@@ -1,19 +1,67 @@
 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."""
 
-def initialize(config=None, **kwargs):
-    if not config:
-        # Keep the default config inside this function.
-        config = {
-            "database": os.environ["DBDatabase"],
-            "host": os.environ["DBHost"],
-            "port": os.environ["DBPort"],
-            "user": os.environ["DBUser"],
-            "password": os.environ["DBPassword"],
+    @staticmethod
+    def initialize(config=None, schema_locked=False, **kwargs):
+        """
+        Initialize PostgreSQL engine with psycopg2 driver.
+        
+        Args:
+            config: Configuration dictionary
+            schema_locked: Boolean to lock schema modifications
+            **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"),
         }
-    config.update(kwargs)
-    return engine.Engine(psycopg2, config, SQL)
+        
+        # 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)
+        
+        # Check for environment variable override for schema locking
+        if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+            schema_locked = True
+        
+        return engine.Engine(psycopg2, final_config, SQL, schema_locked=schema_locked)
+
+
+# Maintain backward compatibility
+def initialize(config=None, schema_locked=False, **kwargs):
+    """Backward compatible initialization function - matches original behavior exactly."""
+    konfig = {
+        "database": os.environ["DBDatabase"],
+        "host": os.environ["DBHost"],
+        "port": os.environ["DBPort"],
+        "user": os.environ["DBUser"],
+        "password": os.environ["DBPassword"],
+    }
+    konfig.update(config or {})
+    konfig.update(kwargs)
+    
+    # Check for environment variable override for schema locking
+    if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+        schema_locked = True
+        
+    return engine.Engine(psycopg2, konfig, SQL, schema_locked=schema_locked)

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 = {
     "<>": "<>",
     "!=": "<>",