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

t_sql-4.9.3/README.md → t_sql-4.11.0/PKG-INFO

@@ -1,3 +1,13 @@
+Metadata-Version: 2.4
+Name: t-sql
+Version: 4.11.0
+Summary: Safe SQL. SQL queries for python t-strings (PEP 750)
+Project-URL: Homepage, https://github.com/nhumrich/t-sql
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: alembic>=1.17.0
+Description-Content-Type: text/markdown
+
 # t-sql
 
 A lightweight SQL templating library that leverages Python 3.14's t-strings (PEP 750).
@@ -375,6 +385,14 @@ query = Users.insert(id='abc123', username='john', email='john@example.com').ret
 sql, params = query.render()
 # ('INSERT INTO users (id, username, email) VALUES (?, ?, ?) RETURNING *', [...])
 
+# INSERT with all column defaults — no values provided (Postgres/SQLite)
+# Emits `DEFAULT VALUES`; useful when every column has a DB/SA default.
+# Note: MySQL does not support `DEFAULT VALUES` syntax. For MySQL, provide at
+# least one column or use raw SQL (`INSERT INTO t () VALUES ()`).
+query = Users.insert().returning('id')
+sql, params = query.render()
+# ('INSERT INTO users DEFAULT VALUES RETURNING id', [])
+
 # INSERT IGNORE (MySQL)
 query = Users.insert(id='abc123', username='john', email='john@example.com').ignore()
 sql, params = query.render()

t_sql-4.9.3/PKG-INFO → t_sql-4.11.0/README.md

@@ -1,13 +1,3 @@
-Metadata-Version: 2.4
-Name: t-sql
-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
-Requires-Python: >=3.14
-Requires-Dist: alembic>=1.17.0
-Description-Content-Type: text/markdown
-
 # t-sql
 
 A lightweight SQL templating library that leverages Python 3.14's t-strings (PEP 750).
@@ -385,6 +375,14 @@ query = Users.insert(id='abc123', username='john', email='john@example.com').ret
 sql, params = query.render()
 # ('INSERT INTO users (id, username, email) VALUES (?, ?, ?) RETURNING *', [...])
 
+# INSERT with all column defaults — no values provided (Postgres/SQLite)
+# Emits `DEFAULT VALUES`; useful when every column has a DB/SA default.
+# Note: MySQL does not support `DEFAULT VALUES` syntax. For MySQL, provide at
+# least one column or use raw SQL (`INSERT INTO t () VALUES ()`).
+query = Users.insert().returning('id')
+sql, params = query.render()
+# ('INSERT INTO users DEFAULT VALUES RETURNING id', [])
+
 # INSERT IGNORE (MySQL)
 query = Users.insert(id='abc123', username='john', email='john@example.com').ignore()
 sql, params = query.render()

{t_sql-4.9.3 → t_sql-4.11.0}/pyproject.toml

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

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

@@ -457,4 +457,35 @@ async def test_array_with_list(conn):
         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")
+        await conn.execute("DROP TABLE IF EXISTS test_array")
+
+
+async def test_insert_all_defaults_with_returning(conn):
+    """Insert with empty values uses DEFAULT VALUES; all columns have defaults."""
+    from tsql.query_builder import Table, Column
+
+    await conn.execute("""
+        CREATE TABLE IF NOT EXISTS test_defaults (
+            id SERIAL PRIMARY KEY,
+            status VARCHAR(20) DEFAULT 'draft',
+            created_at TIMESTAMP DEFAULT NOW()
+        )
+    """)
+
+    try:
+        class TestDefaults(Table, table_name='test_defaults'):
+            id: Column
+            status: Column
+            created_at: Column
+
+        query, params = TestDefaults.insert().returning('id', 'status').render(
+            style=tsql.styles.NUMERIC_DOLLAR
+        )
+        assert query == 'INSERT INTO test_defaults DEFAULT VALUES RETURNING id, status'
+        assert params == []
+
+        row = await conn.fetchrow(query, *params)
+        assert row['id'] is not None
+        assert row['status'] == 'draft'
+    finally:
+        await conn.execute("DROP TABLE IF EXISTS test_defaults")

{t_sql-4.9.3 → t_sql-4.11.0}/tests/test_query_builder.py

@@ -1208,6 +1208,43 @@ def test_insert_without_metadata_ignores_defaults():
     assert params == ['1', 'test']
 
 
+class _DefaultsTable(Table, table_name='mytable'):
+    id: Column
+    name: Column
+
+
+def test_insert_all_defaults():
+    sql, params = _DefaultsTable.insert().render()
+    assert sql == 'INSERT INTO mytable DEFAULT VALUES'
+    assert params == []
+
+
+def test_insert_all_defaults_with_returning():
+    sql, params = _DefaultsTable.insert().returning('id').render()
+    assert sql == 'INSERT INTO mytable DEFAULT VALUES RETURNING id'
+    assert params == []
+
+
+def test_insert_all_defaults_with_returning_star():
+    sql, params = _DefaultsTable.insert().returning().render()
+    assert sql == 'INSERT INTO mytable DEFAULT VALUES RETURNING *'
+    assert params == []
+
+
+def test_insert_all_defaults_with_on_conflict_do_nothing():
+    sql, params = _DefaultsTable.insert().on_conflict_do_nothing().render()
+    assert sql == 'INSERT INTO mytable DEFAULT VALUES ON CONFLICT DO NOTHING'
+    assert params == []
+
+
+def test_insert_all_defaults_mysql_on_duplicate_raises():
+    import pytest
+
+    builder = _DefaultsTable.insert().on_duplicate_key_update()
+    with pytest.raises(ValueError, match='DEFAULT VALUES'):
+        builder.render()
+
+
 def test_update_with_onupdate_default():
     """Test that onupdate defaults are applied during UPDATE"""
     from sqlalchemy import MetaData, Column as SAColumn, String
@@ -1545,3 +1582,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.3 → t_sql-4.11.0}/tests/test_sqlite_integration.py

@@ -429,3 +429,29 @@ async def test_like_pattern_format_specs(conn):
     # Should match john_doe
     assert len(rows) == 1
     assert rows[0][0] == 'john_doe'
+
+
+async def test_insert_all_defaults_with_returning(conn):
+    """Insert with empty values uses DEFAULT VALUES on SQLite."""
+    from tsql.query_builder import Column
+
+    await conn.execute("""
+        CREATE TABLE test_defaults (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            status TEXT DEFAULT 'draft'
+        )
+    """)
+    await conn.commit()
+
+    class TestDefaults(Table, table_name='test_defaults'):
+        id: Column
+        status: Column
+
+    sql, params = TestDefaults.insert().returning('id', 'status').render()
+    assert sql == 'INSERT INTO test_defaults DEFAULT VALUES RETURNING id, status'
+    assert params == []
+
+    cursor = await conn.execute(sql, params)
+    row = await cursor.fetchone()
+    assert row[0] is not None
+    assert row[1] == 'draft'

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

@@ -69,7 +69,7 @@ def test_correct_final_query_with_literals():
 def test_disallows_bad_literals():
     table = "users'"
     col = "name"
-    with pytest.raises(ValueError):  # TODO: change to appropriate error
+    with pytest.raises(ValueError):
         result = tsql.render(t'select id, {col:literal} from {table:literal}')
 
 

{t_sql-4.9.3 → t_sql-4.11.0}/tsql/query_builder.py

@@ -759,8 +759,9 @@ class InsertBuilder(QueryBuilder):
             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:
+        if not values_dict:
+            parts.append(t'INSERT INTO {table_name:literal} DEFAULT VALUES')
+        elif self._ignore:
             parts.append(t'INSERT IGNORE INTO {table_name:literal} {values_dict:as_values}')
         else:
             parts.append(t'INSERT INTO {table_name:literal} {values_dict:as_values}')
@@ -821,6 +822,10 @@ class InsertBuilder(QueryBuilder):
                     update_dict[col_name] = _process_value_for_builder(value, processor)
                 parts.append(t'ON DUPLICATE KEY UPDATE {update_dict:as_set}')
             else:
+                if not self.values:
+                    raise ValueError(
+                        "ON DUPLICATE KEY UPDATE requires explicit columns when inserting DEFAULT VALUES"
+                    )
                 # Default: update all columns with alias.column (new MySQL syntax)
                 update_parts = []
                 for i, key in enumerate(self.values.keys()):
@@ -932,7 +937,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 +999,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 +1065,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 +1120,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 +1221,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 +1412,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)