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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 4.5.0
+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.5.0 → t_sql-4.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "4.5.0"
+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.5.0 → 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.5.0 → 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.5.0 → 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)

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

@@ -719,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:
@@ -758,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.*
@@ -786,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)
@@ -830,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"""
 
@@ -913,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}')