t-sql 4.9.2__tar.gz → 4.10.0__tar.gz

{t_sql-4.9.2 → t_sql-4.10.0}/PKG-INFO

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

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

{t_sql-4.9.2 → t_sql-4.10.0}/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.2 → t_sql-4.10.0}/tests/test_query_builder.py

@@ -1545,3 +1545,45 @@ def test_multiple_recursive_ctes():
     assert sql.startswith("WITH RECURSIVE")
     assert "normal AS" in sql
     assert "tree AS" in sql
+
+
+def test_where_with_bare_boolean_column():
+    """Test WHERE with bare boolean column (truthy check)"""
+    class Contacts(Table):
+        id: Column
+        is_primary: Column
+
+    query = Contacts.select().where(Contacts.is_primary)
+    sql, params = query.render()
+
+    assert 'WHERE contacts.is_primary' in sql
+    assert params == []
+
+
+def test_update_where_with_bare_boolean_column():
+    """Test UPDATE WHERE with bare boolean column"""
+    class Contacts(Table):
+        id: Column
+        is_primary: Column
+        name: Column
+
+    query = Contacts.update(name='updated').where(Contacts.is_primary)
+    sql, params = query.render()
+
+    assert 'UPDATE contacts SET' in sql
+    assert 'WHERE contacts.is_primary' in sql
+    assert params == ['updated']
+
+
+def test_delete_where_with_bare_boolean_column():
+    """Test DELETE WHERE with bare boolean column"""
+    class Contacts(Table):
+        id: Column
+        is_primary: Column
+
+    query = Contacts.delete().where(Contacts.is_primary)
+    sql, params = query.render()
+
+    assert 'DELETE FROM contacts' in sql
+    assert 'WHERE contacts.is_primary' in sql
+    assert params == []

{t_sql-4.9.2 → t_sql-4.10.0}/tests/test_tsql.py

@@ -218,4 +218,34 @@ def test_empty_collections_preserved():
     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.2 → t_sql-4.10.0}/tsql/__init__.py

@@ -193,11 +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():
-                    return [Parameter(val.expression, value)]
-                case '', dict() | list() | set():
+                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):

{t_sql-4.9.2 → t_sql-4.10.0}/tsql/query_builder.py

@@ -932,7 +932,7 @@ class UpdateBuilder(QueryBuilder):
         string_table = _StringTable(table_name, schema)
         return cls(string_table, values)
 
-    def where(self, condition: Union[Condition, Template]) -> 'UpdateBuilder':
+    def where(self, condition: Union[Condition, Template, Column]) -> 'UpdateBuilder':
         """Add a WHERE condition (multiple calls are ANDed together)"""
         self._conditions.append(condition)
         self._requires_where = False
@@ -994,6 +994,9 @@ class UpdateBuilder(QueryBuilder):
             for cond in self._conditions:
                 if isinstance(cond, Template):
                     where_parts.append(t'({cond})')
+                elif isinstance(cond, Column):
+                    col_str = str(cond)
+                    where_parts.append(t'{col_str:literal}')
                 else:
                     where_parts.append(cond.to_tsql())
             combined_where = t_join(t' AND ', where_parts)
@@ -1057,7 +1060,7 @@ class DeleteBuilder(QueryBuilder):
         string_table = _StringTable(table_name, schema)
         return cls(string_table)
 
-    def where(self, condition: Union[Condition, Template]) -> 'DeleteBuilder':
+    def where(self, condition: Union[Condition, Template, Column]) -> 'DeleteBuilder':
         """Add a WHERE condition (multiple calls are ANDed together)"""
         self._conditions.append(condition)
         self._requires_where = False
@@ -1112,6 +1115,9 @@ class DeleteBuilder(QueryBuilder):
             for cond in self._conditions:
                 if isinstance(cond, Template):
                     where_parts.append(t'({cond})')
+                elif isinstance(cond, Column):
+                    col_str = str(cond)
+                    where_parts.append(t'{col_str:literal}')
                 else:
                     where_parts.append(cond.to_tsql())
             combined_where = t_join(t' AND ', where_parts)
@@ -1210,7 +1216,7 @@ class SelectQueryBuilder(QueryBuilder):
             self._columns = None
         return self
 
-    def where(self, condition: Union[Condition, Template]) -> 'SelectQueryBuilder':
+    def where(self, condition: Union[Condition, Template, Column]) -> 'SelectQueryBuilder':
         """Add a WHERE condition (multiple calls are ANDed together)
 
         Accepts either Condition objects from query builder or raw t-string Templates
@@ -1401,6 +1407,9 @@ class SelectQueryBuilder(QueryBuilder):
             for cond in self._conditions:
                 if isinstance(cond, Template):
                     where_parts.append(t'({cond})')
+                elif isinstance(cond, Column):
+                    col_str = str(cond)
+                    where_parts.append(t'{col_str:literal}')
                 else:
                     where_parts.append(cond.to_tsql())
             combined_where = t_join(t' AND ', where_parts)