t-sql 4.4.2__tar.gz → 4.5.1__tar.gz

{t_sql-4.4.2 → t_sql-4.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 4.4.2
+Version: 4.5.1
 Summary: Safe SQL. SQL queries for python t-strings (PEP 750)
 Project-URL: Homepage, https://github.com/nhumrich/t-sql
 License-File: LICENSE

{t_sql-4.4.2 → t_sql-4.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "4.4.2"
+version = "4.5.1"
 description = "Safe SQL. SQL queries for python t-strings (PEP 750)"
 readme = "README.md"
 requires-python = ">=3.14"

{t_sql-4.4.2 → t_sql-4.5.1}/tests/test_asyncpg_integration.py

@@ -1,4 +1,5 @@
 import asyncpg
+import datetime
 import os
 import pytest
 
@@ -234,4 +235,37 @@ async def test_escaped_handles_comment_injection(conn):
     malicious_input = "admin'--"
     query, _ = tsql.render(t"SELECT * FROM test_users WHERE name = {malicious_input}", style=tsql.styles.ESCAPED)
     rows = await conn.fetch(query)
-    assert len(rows) == 0
+    assert len(rows) == 0
+
+
+async def test_datetime_comparison_with_asyncpg(conn):
+    """Test that datetime objects work correctly with asyncpg (bug fix verification)"""
+    # Insert some test data with specific timestamps
+    base_time = datetime.datetime.now()
+
+    await conn.execute(
+        "INSERT INTO test_users (name, created_at) VALUES ($1, $2), ($3, $4), ($5, $6)",
+        'User1', base_time - datetime.timedelta(minutes=30),
+        'User2', base_time - datetime.timedelta(minutes=10),
+        'User3', base_time - datetime.timedelta(minutes=5)
+    )
+
+    # Use a datetime object in a WHERE clause (this was broken before the fix)
+    cutoff_time = base_time - datetime.timedelta(minutes=15)
+
+    query, params = tsql.render(
+        t"SELECT name FROM test_users WHERE created_at > {cutoff_time}",
+        style=tsql.styles.NUMERIC_DOLLAR
+    )
+
+    # Verify the parameter is still a datetime object (not stringified)
+    assert len(params) == 1
+    assert isinstance(params[0], datetime.datetime)
+
+    # This should work without asyncpg throwing a DataError
+    rows = await conn.fetch(query, *params)
+
+    # Should find User2 and User3 (created within last 15 minutes)
+    assert len(rows) == 2
+    names = sorted([row['name'] for row in rows])
+    assert names == ['User2', 'User3']

t_sql-4.5.1/tests/test_template_in_builders.py

@@ -0,0 +1,104 @@
+"""Tests for Template/TSQL values in INSERT/UPDATE builders"""
+import pytest
+from string.templatelib import Template
+
+import tsql
+from tsql import TSQL
+from tsql.query_builder import Table, SAColumn
+from tsql import styles
+
+# Test tables
+class TestTable(Table, table_name='test_table'):
+    id = ...
+    name = ...
+    created_ts = ...
+    updated_ts = ...
+
+
+def test_update_with_template_value():
+    """Template values in UPDATE should be inlined, not parameterized"""
+    query = TestTable.update(updated_ts=t"NOW()").where(TestTable.id == 123)
+
+    sql, params = query.render(style=styles.QMARK)
+
+    # The Template should be inlined, not parameterized
+    assert "NOW()" in sql
+    assert sql == "UPDATE test_table SET updated_ts = NOW() WHERE test_table.id = ?"
+    # Only the id comparison should be parameterized
+    assert params == [123]
+
+
+def test_insert_with_template_value():
+    """Template values in INSERT should be inlined, not parameterized"""
+    query = TestTable.insert(name="Alice", created_ts=t"NOW()")
+
+    sql, params = query.render(style=styles.QMARK)
+
+    # The Template should be inlined, not parameterized
+    assert "NOW()" in sql
+    assert sql == "INSERT INTO test_table (name, created_ts) VALUES (?, NOW())"
+    # Only the name should be parameterized
+    assert params == ["Alice"]
+
+
+def test_insert_on_conflict_update_with_template():
+    """Template values in ON CONFLICT UPDATE should be inlined"""
+    query = (TestTable.insert(id=1, name="Alice", updated_ts=t"NOW()")
+             .on_conflict_update('id', update={'updated_ts': t"NOW()"}))
+
+    sql, params = query.render(style=styles.QMARK)
+
+    # Both Templates should be inlined
+    assert sql.count("NOW()") == 2
+    assert "ON CONFLICT (id) DO UPDATE SET updated_ts = NOW()" in sql
+
+
+def test_insert_on_duplicate_key_with_template():
+    """Template values in ON DUPLICATE KEY UPDATE should be inlined (MySQL)"""
+    query = (TestTable.insert(id=1, name="Alice", updated_ts=t"NOW()")
+             .on_duplicate_key_update(update={'updated_ts': t"NOW()"}))
+
+    sql, params = query.render(style=styles.QMARK)
+
+    # Both Templates should be inlined
+    assert sql.count("NOW()") == 2
+    assert "ON DUPLICATE KEY UPDATE updated_ts = NOW()" in sql
+
+
+def test_update_with_tsql_object():
+    """TSQL objects in UPDATE should be inlined"""
+    now_expr = TSQL(t"NOW()")
+    query = TestTable.update(updated_ts=now_expr).where(TestTable.id == 123)
+
+    sql, params = query.render(style=styles.QMARK)
+
+    assert "NOW()" in sql
+    assert params == [123]
+
+
+def test_update_multiple_template_values():
+    """Multiple Template values should all be inlined"""
+    query = (TestTable.update(
+        created_ts=t"NOW()",
+        updated_ts=t"CURRENT_TIMESTAMP",
+        name="Bob"
+    ).where(TestTable.id == 456))
+
+    sql, params = query.render(style=styles.QMARK)
+
+    # Both SQL expressions should be inlined
+    assert "NOW()" in sql
+    assert "CURRENT_TIMESTAMP" in sql
+    # Only name and id should be parameterized
+    assert params == ["Bob", 456]
+
+
+def test_insert_with_sql_expression_postgres_style():
+    """Template with SQL expression should work with different parameter styles"""
+    query = TestTable.insert(name="Charlie", created_ts=t"NOW() - INTERVAL '5 minutes'")
+
+    sql, params = query.render(style=styles.NUMERIC_DOLLAR)
+
+    assert "NOW() - INTERVAL '5 minutes'" in sql
+    assert sql == "INSERT INTO test_table (name, created_ts) VALUES ($1, NOW() - INTERVAL '5 minutes')"
+    assert params == ["Charlie"]

{t_sql-4.4.2 → t_sql-4.5.1}/tests/test_tsql.py

@@ -1,4 +1,5 @@
 import pytest
+import datetime
 
 import tsql
 import tsql.styles
@@ -111,6 +112,49 @@ def test_prevents_sql_injection():
     assert result[0] == "SELECT * FROM table WHERE col=?"
 
 
+def test_datetime_preserved_as_native_type():
+    """datetime objects should be passed through unchanged, not stringified"""
+    dt = datetime.datetime(2025, 10, 21, 12, 30, 45, 123456, tzinfo=datetime.timezone.utc)
+    result = tsql.render(t"SELECT * FROM table WHERE created_at > {dt}")
+    assert result[0] == "SELECT * FROM table WHERE created_at > ?"
+    assert result[1] == [dt]
+    assert isinstance(result[1][0], datetime.datetime)
+
+
+def test_date_preserved_as_native_type():
+    """date objects should be passed through unchanged"""
+    d = datetime.date(2025, 10, 21)
+    result = tsql.render(t"SELECT * FROM table WHERE date_col = {d}")
+    assert result[0] == "SELECT * FROM table WHERE date_col = ?"
+    assert result[1] == [d]
+    assert isinstance(result[1][0], datetime.date)
+
+
+def test_time_preserved_as_native_type():
+    """time objects should be passed through unchanged"""
+    t = datetime.time(12, 30, 45)
+    result = tsql.render(t"SELECT * FROM table WHERE time_col = {t}")
+    assert result[0] == "SELECT * FROM table WHERE time_col = ?"
+    assert result[1] == [t]
+    assert isinstance(result[1][0], datetime.time)
+
+
+def test_timedelta_preserved_as_native_type():
+    """timedelta objects should be passed through unchanged"""
+    td = datetime.timedelta(days=15, hours=3, minutes=30)
+    result = tsql.render(t"SELECT * FROM table WHERE interval_col = {td}")
+    assert result[0] == "SELECT * FROM table WHERE interval_col = ?"
+    assert result[1] == [td]
+    assert isinstance(result[1][0], datetime.timedelta)
+
+
+def test_datetime_with_format_spec_converts_to_string():
+    """When a format spec is provided, datetime should be formatted as string"""
+    dt = datetime.datetime(2025, 10, 21, 12, 30, 45)
+    result = tsql.render(t"SELECT * FROM table WHERE date_str = {dt:%Y-%m-%d}")
+    assert result[0] == "SELECT * FROM table WHERE date_str = ?"
+    assert result[1] == ['2025-10-21']
+    assert isinstance(result[1][0], str)
 
 
 

{t_sql-4.4.2 → t_sql-4.5.1}/tests/test_type_processor.py

@@ -291,12 +291,14 @@ def test_map_results_with_joins_and_aliases():
         }
     ]
 
-    query.map_results(rows)
+    results = query.map_results(rows)
 
     # Check aliased column was decrypted
-    assert rows[0]["social"] == "123-45-6789"
+    assert results[0]["social"] == "123-45-6789"
+    assert results[0].social == "123-45-6789"  # Test attribute access
     # Check joined table column was deserialized
-    assert rows[0]["metadata_col"] == {"key": "value"}
+    assert results[0]["metadata_col"] == {"key": "value"}
+    assert results[0].metadata_col == {"key": "value"}  # Test attribute access
 
     # Test with SELECT * (should process all columns from all tables)
     query_star = User.select().join(Profile, on=User.id == Profile.user_id)
@@ -311,8 +313,10 @@ def test_map_results_with_joins_and_aliases():
         }
     ]
 
-    query_star.map_results(rows_star)
+    results_star = query_star.map_results(rows_star)
 
     # Both processors should be applied
-    assert rows_star[0]["ssn"] == "987-65-4321"
-    assert rows_star[0]["metadata_col"] == {"foo": "bar"}
+    assert results_star[0]["ssn"] == "987-65-4321"
+    assert results_star[0].ssn == "987-65-4321"  # Test attribute access
+    assert results_star[0]["metadata_col"] == {"foo": "bar"}
+    assert results_star[0].metadata_col == {"foo": "bar"}  # Test attribute access

{t_sql-4.4.2 → t_sql-4.5.1}/tsql/__init__.py

@@ -1,5 +1,6 @@
 import re
 import string
+import datetime
 from typing import NamedTuple, Tuple, Any, List, Dict, Iterable, Union, TYPE_CHECKING
 from string.templatelib import Template, Interpolation
 
@@ -127,6 +128,8 @@ class TSQL:
                     return [Parameter(val.expression, value)]
                 case _, int():
                     return [Parameter(val.expression, val.value)]
+                case '', datetime.datetime() | datetime.date() | datetime.time() | datetime.timedelta():
+                    return [Parameter(val.expression, value)]
                 case _, _:
                     return [Parameter(val.expression, formatter.format_field(value, val.format_spec))]
 
@@ -179,7 +182,20 @@ def as_values(value_dict: dict[str, Any]):
     for i, value in enumerate(values):
         if i > 0:
             value_parts.append(', ')
-        value_parts.append(Parameter(f'value_{i}', value))
+
+        # Handle special types that should be inlined as SQL
+        if isinstance(value, Template):
+            # Inline the Template by processing it through _sqlize
+            value_parts.extend(TSQL._sqlize(value))
+        elif isinstance(value, TSQL):
+            # Inline the TSQL object's parts directly
+            value_parts.extend(value._sql_parts)
+        elif hasattr(value, 'to_tsql'):
+            # Handle QueryBuilder objects
+            value_parts.extend(value.to_tsql()._sql_parts)
+        else:
+            # Normal value - create Parameter
+            value_parts.append(Parameter(f'value_{i}', value))
     value_parts.append(')')
 
     # Create TSQL object manually
@@ -208,7 +224,20 @@ def as_set(value_dict: dict[str, Any]):
             set_parts.append(', ')
         set_parts.append(key)
         set_parts.append(' = ')
-        set_parts.append(Parameter(f'value_{i}', value))
+
+        # Handle special types that should be inlined as SQL
+        if isinstance(value, Template):
+            # Inline the Template by processing it through _sqlize
+            set_parts.extend(TSQL._sqlize(value))
+        elif isinstance(value, TSQL):
+            # Inline the TSQL object's parts directly
+            set_parts.extend(value._sql_parts)
+        elif hasattr(value, 'to_tsql'):
+            # Handle QueryBuilder objects
+            set_parts.extend(value.to_tsql()._sql_parts)
+        else:
+            # Normal value - create Parameter
+            set_parts.append(Parameter(f'value_{i}', value))
 
     # Create TSQL object manually
     tsql_obj = TSQL.__new__(TSQL)
@@ -362,6 +391,7 @@ def delete(table: str, id: str | int) -> TSQL:
 
 from tsql.query_builder import UnsafeQueryError
 from tsql.type_processor import TypeProcessor
+from tsql.row import Row
 
 __all__ = [
     'TSQL',
@@ -375,5 +405,6 @@ __all__ = [
     'set_style',
     'UnsafeQueryError',
     'TypeProcessor',
+    'Row',
 ]
 

{t_sql-4.4.2 → t_sql-4.5.1}/tsql/query_builder.py

@@ -4,6 +4,7 @@ from datetime import datetime
 from abc import ABC, abstractmethod
 
 from tsql import TSQL, t_join
+from tsql.row import Row
 
 
 class UnsafeQueryError(Exception):
@@ -559,26 +560,28 @@ class QueryBuilder(ABC):
         """
         return self.to_tsql().render(style)
 
-    def map_results(self, rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def map_results(self, rows: List[Dict[str, Any]]) -> List[Row]:
         """Transform database rows with type processors applied.
 
         This method applies process_result_value from type processors to convert
         database values back to Python values (e.g., decrypt encrypted fields,
         deserialize JSON, etc.).
 
-        Modifies row objects in place to preserve driver-specific row types
-        (e.g., asyncpg Record objects).
+        Returns Row objects (dict subclass with attribute access) for consistent
+        API regardless of input type (dict, asyncpg Record, etc.).
 
         Args:
             rows: List of row objects from database query results
 
         Returns:
-            The same list of rows with transformed values (mutated in place)
+            List of Row objects with transformed values
 
         Example:
             query = User.select().where(User.id == 1)
             rows = await conn.fetch(*query.render())
-            query.map_results(rows)  # ssn decrypted, metadata deserialized (in place)
+            results = query.map_results(rows)
+            print(results[0].name)  # Attribute access
+            print(results[0]['name'])  # Dict access
         """
         if not hasattr(self, 'base_table'):
             raise AttributeError("map_results requires a base_table attribute")
@@ -602,13 +605,16 @@ class QueryBuilder(ABC):
             for table in tables:
                 processors.update(table._type_processors)
 
-        # Apply processors to rows in place
+        # Convert to Row objects and apply processors
+        results = []
         for row in rows:
-            for col_name in list(row.keys()):
+            row_dict = Row(row)  # Converts dict/Record to Row
+            for col_name in list(row_dict.keys()):
                 if col_name in processors:
-                    row[col_name] = processors[col_name].process_result_value(row[col_name])
+                    row_dict[col_name] = processors[col_name].process_result_value(row_dict[col_name])
+            results.append(row_dict)
 
-        return rows
+        return results
 
 
 class InsertBuilder(QueryBuilder):
@@ -713,11 +719,8 @@ class InsertBuilder(QueryBuilder):
         # Apply type processors to values
         values_dict = {}
         for col_name, value in self.values.items():
-            if col_name in self.base_table._type_processors:
-                processor = self.base_table._type_processors[col_name]
-                values_dict[col_name] = processor.process_bind_param(value)
-            else:
-                values_dict[col_name] = value
+            processor = self.base_table._type_processors.get(col_name)
+            values_dict[col_name] = _process_value_for_builder(value, processor)
 
         # MySQL INSERT IGNORE
         if self._ignore:
@@ -752,11 +755,8 @@ class InsertBuilder(QueryBuilder):
                 # User specified which columns to update - apply type processors
                 update_dict = {}
                 for col_name, value in self._update_cols.items():
-                    if col_name in self.base_table._type_processors:
-                        processor = self.base_table._type_processors[col_name]
-                        update_dict[col_name] = processor.process_bind_param(value)
-                    else:
-                        update_dict[col_name] = value
+                    processor = self.base_table._type_processors.get(col_name)
+                    update_dict[col_name] = _process_value_for_builder(value, processor)
                 parts.append(t'ON CONFLICT ({conflict_cols_str:unsafe}) DO UPDATE SET {update_dict:as_set}')
             else:
                 # Default: update all non-conflict columns with EXCLUDED.*
@@ -780,11 +780,8 @@ class InsertBuilder(QueryBuilder):
                 # Apply type processors
                 update_dict = {}
                 for col_name, value in self._update_cols.items():
-                    if col_name in self.base_table._type_processors:
-                        processor = self.base_table._type_processors[col_name]
-                        update_dict[col_name] = processor.process_bind_param(value)
-                    else:
-                        update_dict[col_name] = value
+                    processor = self.base_table._type_processors.get(col_name)
+                    update_dict[col_name] = _process_value_for_builder(value, processor)
                 parts.append(t'ON DUPLICATE KEY UPDATE {update_dict:as_set}')
             else:
                 # Default: update all columns with alias.column (new MySQL syntax)
@@ -824,6 +821,30 @@ class InsertBuilder(QueryBuilder):
             return f"InsertBuilder(<error rendering: {e}>)"
 
 
+def _process_value_for_builder(value: Any, type_processor: Any = None) -> Any:
+    """Apply type processor to a value if appropriate.
+
+    This helper ensures Template, TSQL, and QueryBuilder objects are not processed
+    by TypeProcessors, allowing them to be inlined as SQL instead of parameterized.
+
+    Args:
+        value: The value to potentially process
+        type_processor: Optional TypeProcessor instance
+
+    Returns:
+        Processed value (or unchanged if special type or no processor)
+    """
+    # Don't process special types that should be inlined as SQL
+    if isinstance(value, (Column, Template)) or hasattr(value, 'to_tsql'):
+        return value
+
+    # Apply processor if present (this handles None correctly - processors can transform it)
+    if type_processor is not None:
+        return type_processor.process_bind_param(value)
+
+    return value
+
+
 class UpdateBuilder(QueryBuilder):
     """Fluent interface for building UPDATE queries"""
 
@@ -907,11 +928,8 @@ class UpdateBuilder(QueryBuilder):
         # Apply type processors to values
         values_dict = {}
         for col_name, value in self.values.items():
-            if col_name in self.base_table._type_processors:
-                processor = self.base_table._type_processors[col_name]
-                values_dict[col_name] = processor.process_bind_param(value)
-            else:
-                values_dict[col_name] = value
+            processor = self.base_table._type_processors.get(col_name)
+            values_dict[col_name] = _process_value_for_builder(value, processor)
 
         parts.append(t'UPDATE {table_name:literal} SET {values_dict:as_set}')
 

t_sql-4.5.1/tsql/row.py

@@ -0,0 +1,39 @@
+"""Row object - dict with attribute access support."""
+
+
+class Row(dict):
+    """A dict subclass that supports attribute-style access.
+
+    Provides a nicer API for accessing row data while maintaining
+    full dict compatibility.
+
+    Example:
+        row = Row({'id': 1, 'name': 'Alice'})
+        print(row.id)        # 1 (attribute access)
+        print(row['name'])   # Alice (dict access)
+        row.age = 30         # Set via attribute
+        print(row['age'])    # 30
+    """
+
+    def __getattr__(self, key: str):
+        """Allow attribute-style access to dict keys."""
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(f"Row has no attribute {key!r}") from None
+
+    def __setattr__(self, key: str, value):
+        """Allow attribute-style setting of dict keys."""
+        self[key] = value
+
+    def __delattr__(self, key: str):
+        """Allow attribute-style deletion of dict keys."""
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"Row has no attribute {key!r}") from None
+
+    def __repr__(self) -> str:
+        """Nice repr for debugging."""
+        items = ', '.join(f'{k}={v!r}' for k, v in self.items())
+        return f"Row({items})"