t-sql 4.9.1__tar.gz → 4.9.3__tar.gz

{t_sql-4.9.1 → t_sql-4.9.3}/PKG-INFO

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

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

{t_sql-4.9.1 → t_sql-4.9.3}/tests/test_asyncpg_integration.py

@@ -369,4 +369,92 @@ async def test_like_pattern_format_specs_with_postgres(conn):
     rows = await conn.fetch(sql, *params)
 
     # Should match both john_doe and john%smith (case-insensitive)
-    assert len(rows) == 2
+    assert len(rows) == 2
+
+
+async def test_jsonb_with_dict(conn):
+    """Test that dict objects can be used with asyncpg JSONB columns via set_type_codec"""
+    import json
+
+    # Create a table with JSONB column
+    await conn.execute("""
+        CREATE TABLE IF NOT EXISTS test_jsonb (
+            id SERIAL PRIMARY KEY,
+            data JSONB
+        )
+    """)
+
+    try:
+        # Set up a codec so asyncpg can handle Python dicts for JSONB
+        # This is the recommended asyncpg pattern for JSONB
+        await conn.set_type_codec(
+            'jsonb',
+            encoder=json.dumps,
+            decoder=json.loads,
+            schema='pg_catalog'
+        )
+
+        # Now dicts work directly because tsql preserves them (not stringified)
+        my_dict = {'name': 'billy', 'age': 30, 'tags': ['admin', 'user']}
+
+        query, params = tsql.render(
+            t"INSERT INTO test_jsonb (data) VALUES ({my_dict})",
+            style=tsql.styles.NUMERIC_DOLLAR
+        )
+
+        # Verify the parameter is still a dict (not stringified)
+        assert len(params) == 1
+        assert isinstance(params[0], dict)
+
+        # This should work now with the type codec
+        await conn.execute(query, *params)
+
+        # Verify data was inserted correctly and can be queried
+        row = await conn.fetchrow("SELECT data FROM test_jsonb WHERE id = 1")
+        assert row['data'] == my_dict
+        assert row['data']['name'] == 'billy'
+        assert row['data']['tags'] == ['admin', 'user']
+
+        # Test querying with JSONB operators
+        name = 'billy'
+        query2, params2 = tsql.render(
+            t"SELECT data FROM test_jsonb WHERE data->>'name' = {name}",
+            style=tsql.styles.NUMERIC_DOLLAR
+        )
+        rows = await conn.fetch(query2, *params2)
+        assert len(rows) == 1
+    finally:
+        await conn.execute("DROP TABLE IF EXISTS test_jsonb")
+
+
+async def test_array_with_list(conn):
+    """Test that list objects work correctly with asyncpg array columns"""
+    # Create a table with array column
+    await conn.execute("""
+        CREATE TABLE IF NOT EXISTS test_array (
+            id SERIAL PRIMARY KEY,
+            tags TEXT[]
+        )
+    """)
+
+    try:
+        # Insert a list - this should work because list is preserved
+        my_list = ['tag1', 'tag2', 'tag3']
+
+        query, params = tsql.render(
+            t"INSERT INTO test_array (tags) VALUES ({my_list})",
+            style=tsql.styles.NUMERIC_DOLLAR
+        )
+
+        # Verify the parameter is still a list (not stringified)
+        assert len(params) == 1
+        assert isinstance(params[0], list)
+
+        # This should work without asyncpg throwing an error
+        await conn.execute(query, *params)
+
+        # Verify data was inserted correctly
+        row = await conn.fetchrow("SELECT tags FROM test_array WHERE id = 1")
+        assert row['tags'] == my_list
+    finally:
+        await conn.execute("DROP TABLE IF EXISTS test_array")

{t_sql-4.9.1 → t_sql-4.9.3}/tests/test_escaped.py

@@ -123,8 +123,8 @@ def test_escaped_handles_float_values():
     """Test proper escaping of float values"""
     price = 19.99
     result = tsql.render(t"SELECT * FROM products WHERE price = {price}", style=tsql.styles.ESCAPED)
-    # Note: floats get converted to strings by the formatter before reaching ESCAPED style
-    assert result[0] == "SELECT * FROM products WHERE price = '19.99'"
+    # Floats are passed through and rendered as numeric (no quotes) - correct SQL behavior
+    assert result[0] == "SELECT * FROM products WHERE price = 19.99"
     assert result[1] == []
 
 

{t_sql-4.9.1 → t_sql-4.9.3}/tests/test_tsql.py

@@ -168,4 +168,84 @@ def test_datetime_with_format_spec_converts_to_string():
     assert isinstance(result[1][0], str)
 
 
+def test_dict_preserved_as_native_type():
+    """Dict values should pass through as dict objects, not strings."""
+    my_dict = {'name': 'billy', 'age': 30}
+    result = tsql.render(t'INSERT INTO users (data) VALUES ({my_dict})')
+    assert result.sql == 'INSERT INTO users (data) VALUES (?)'
+    assert result.values == [{'name': 'billy', 'age': 30}]
+    assert isinstance(result.values[0], dict)
+
+
+def test_list_preserved_as_native_type():
+    """List values should pass through as list objects, not strings."""
+    my_list = [1, 2, 3, 'four']
+    result = tsql.render(t'INSERT INTO items (tags) VALUES ({my_list})')
+    assert result.sql == 'INSERT INTO items (tags) VALUES (?)'
+    assert result.values == [[1, 2, 3, 'four']]
+    assert isinstance(result.values[0], list)
+
+
+def test_set_preserved_as_native_type():
+    """Set values should pass through as set objects, not strings."""
+    my_set = {1, 2, 3}
+    result = tsql.render(t'INSERT INTO items (ids) VALUES ({my_set})')
+    assert result.sql == 'INSERT INTO items (ids) VALUES (?)'
+    assert isinstance(result.values[0], set)
+    assert result.values[0] == {1, 2, 3}
+
+
+def test_nested_dict_with_list():
+    """Nested structures should preserve their types."""
+    data = {'tags': ['a', 'b'], 'count': 5}
+    result = tsql.render(t'UPDATE users SET meta = {data}')
+    assert isinstance(result.values[0], dict)
+    assert isinstance(result.values[0]['tags'], list)
+
+
+def test_empty_collections_preserved():
+    """Empty collections should also preserve their types."""
+    empty_dict = {}
+    empty_list = []
+    empty_set = set()
+
+    r1 = tsql.render(t'VALUES ({empty_dict})')
+    r2 = tsql.render(t'VALUES ({empty_list})')
+    r3 = tsql.render(t'VALUES ({empty_set})')
+
+    assert isinstance(r1.values[0], dict)
+    assert isinstance(r2.values[0], list)
+    assert isinstance(r3.values[0], set)
+
+
+def test_custom_object_preserved():
+    """Custom objects should pass through for database drivers with custom codecs."""
+    class Point:
+        def __init__(self, x, y):
+            self.x = x
+            self.y = y
+
+    p = Point(3, 4)
+    result = tsql.render(t'INSERT INTO coords (loc) VALUES ({p})')
+    assert result.sql == 'INSERT INTO coords (loc) VALUES (?)'
+    assert isinstance(result.values[0], Point)
+    assert result.values[0].x == 3
+    assert result.values[0].y == 4
+
+
+def test_custom_object_with_format_spec_stringifies():
+    """Custom objects WITH a format spec should be formatted (stringified)."""
+    class Point:
+        def __init__(self, x, y):
+            self.x = x
+            self.y = y
+        def __format__(self, spec):
+            return f"POINT({self.x},{self.y})"
+
+    p = Point(3, 4)
+    result = tsql.render(t'INSERT INTO coords (loc) VALUES ({p:s})')
+    assert result.values[0] == "POINT(3,4)"
+    assert isinstance(result.values[0], str)
+
+
 

{t_sql-4.9.1 → t_sql-4.9.3}/tsql/__init__.py

@@ -193,9 +193,11 @@ class TSQL:
                     return [Parameter(val.expression, value)]
                 case _, int():
                     return [Parameter(val.expression, val.value)]
-                case '', datetime.datetime() | datetime.date() | datetime.time() | datetime.timedelta():
+                case '', _:
+                    # No format spec - pass through value as-is for database driver to handle
                     return [Parameter(val.expression, value)]
                 case _, _:
+                    # Has format spec - apply formatting (e.g., {dt:%Y-%m-%d})
                     return [Parameter(val.expression, formatter.format_field(value, val.format_spec))]
 
         if isinstance(val, Template):