t-sql 1.1.0__tar.gz → 1.2.0__tar.gz

{t_sql-1.1.0 → t_sql-1.2.0}/PKG-INFO

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

t_sql-1.2.0/context7.json

@@ -0,0 +1,26 @@
+{
+  "excludeFolders": [
+    "tests",
+    ".github",
+    ".git",
+    "__pycache__",
+    "*.egg-info"
+  ],
+  "excludeFiles": [
+    "LICENSE",
+    "CHANGELOG.md",
+    ".gitignore"
+  ],
+  "rules": [
+    "CRITICAL: This library requires Python 3.14+ due to PEP 750 t-strings. Never suggest it for older Python versions.",
+    "Install with 'uv add t-sql' or 'pip install t-sql'. Use 't-sql[sqlalchemy]' for SQLAlchemy/Alembic integration.",
+    "Always use t-strings (t\"...\") not regular strings (\"\") or f-strings (f\"\"\") for SQL queries. The library is designed so raw strings won't work - this prevents SQL injection by design.",
+    "Use the query builder (@table decorator with typed columns) for complex multi-table joins and structured queries. Use t-string templating for simpler queries or custom SQL logic that the query builder doesn't support.",
+    "The :literal format spec is for dynamic table/column names that cannot be parameterized. It sanitizes against valid SQL identifiers.",
+    "The :unsafe format spec bypasses all safety checks. Only use with hardcoded strings, never with user input.",
+    "The :as_values format spec converts dicts to INSERT VALUES format. The :as_set format spec converts dicts to UPDATE SET format.",
+    "When mixing query builder with t-strings using .where(), t-string conditions are automatically wrapped in parentheses for proper operator precedence.",
+    "The @table decorator returns an instance - use the decorated class directly, don't instantiate it.",
+    "Default parameter style is QMARK (?). Use tsql.styles.NUMERIC_DOLLAR for PostgreSQL ($1, $2), or other styles as needed."
+  ]
+}

{t_sql-1.1.0 → t_sql-1.2.0}/pyproject.toml

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

{t_sql-1.1.0 → t_sql-1.2.0}/tests/test_asyncpg_integration.py

@@ -233,4 +233,95 @@ 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_upsert_insert_new_row(conn):
+    """Test upsert inserts a new row when no conflict exists"""
+    values = {
+        'id': 1,
+        'name': 'Alice',
+        'age': 30
+    }
+
+    query = tsql.upsert('test_users', values, conflict_on='id')
+    sql, params = query.render(style=tsql.styles.NUMERIC_DOLLAR)
+
+    result = await conn.fetchrow(sql, *params)
+
+    assert result['id'] == 1
+    assert result['name'] == 'Alice'
+    assert result['age'] == 30
+
+
+async def test_upsert_updates_on_conflict(conn):
+    """Test upsert updates existing row on conflict"""
+    # Insert initial row
+    await conn.execute(
+        "INSERT INTO test_users (id, name, age) VALUES ($1, $2, $3)",
+        1, 'Alice', 30
+    )
+
+    # Upsert with same id but different values
+    values = {
+        'id': 1,
+        'name': 'Alice Updated',
+        'age': 31
+    }
+
+    query = tsql.upsert('test_users', values, conflict_on='id')
+    sql, params = query.render(style=tsql.styles.NUMERIC_DOLLAR)
+
+    result = await conn.fetchrow(sql, *params)
+
+    # Should update the existing row
+    assert result['id'] == 1
+    assert result['name'] == 'Alice Updated'
+    assert result['age'] == 31
+
+    # Verify only one row exists
+    count = await conn.fetchval("SELECT COUNT(*) FROM test_users")
+    assert count == 1
+
+
+async def test_upsert_multiple_conflict_columns(conn):
+    """Test upsert with composite unique constraint"""
+    # Create a table with composite unique constraint
+    await conn.execute("""
+        CREATE TABLE IF NOT EXISTS test_emails (
+            user_id INTEGER,
+            email VARCHAR(100),
+            verified BOOLEAN,
+            UNIQUE(user_id, email)
+        )
+    """)
+
+    try:
+        # Insert initial row
+        await conn.execute(
+            "INSERT INTO test_emails (user_id, email, verified) VALUES ($1, $2, $3)",
+            1, 'alice@example.com', False
+        )
+
+        # Upsert with same user_id and email
+        values = {
+            'user_id': 1,
+            'email': 'alice@example.com',
+            'verified': True
+        }
+
+        query = tsql.upsert('test_emails', values, conflict_on=['user_id', 'email'])
+        sql, params = query.render(style=tsql.styles.NUMERIC_DOLLAR)
+
+        result = await conn.fetchrow(sql, *params)
+
+        # Should update verified status
+        assert result['user_id'] == 1
+        assert result['email'] == 'alice@example.com'
+        assert result['verified'] is True
+
+        # Verify only one row exists
+        count = await conn.fetchval("SELECT COUNT(*) FROM test_emails")
+        assert count == 1
+    finally:
+        await conn.execute("DROP TABLE IF EXISTS test_emails")

{t_sql-1.1.0 → t_sql-1.2.0}/tests/test_helper_functions.py

@@ -151,4 +151,79 @@ def test_select_int_id_safe():
 
     # Int should be parameterized
     assert "?" in query
-    assert params == [42]
+    assert params == [42]
+
+
+def test_upsert_single_conflict():
+    """Test upsert with a single conflict column"""
+    values = {
+        'email': 'test@example.com',
+        'name': 'Alice',
+        'age': 30
+    }
+
+    query = tsql.upsert('users', values, conflict_on='email')
+    result = tsql.render(query)
+
+    assert "INSERT INTO users" in result[0]
+    assert "email" in result[0] and "name" in result[0] and "age" in result[0]
+    assert "ON CONFLICT (email)" in result[0]
+    assert "DO UPDATE SET" in result[0]
+    assert "name = EXCLUDED.name" in result[0]
+    assert "age = EXCLUDED.age" in result[0]
+    assert "email = EXCLUDED.email" not in result[0]  # Conflict column shouldn't be in UPDATE
+    assert result[1] == ['test@example.com', 'Alice', 30]
+
+
+def test_upsert_multiple_conflicts():
+    """Test upsert with multiple conflict columns"""
+    values = {
+        'email': 'test@example.com',
+        'username': 'alice',
+        'name': 'Alice Smith'
+    }
+
+    query = tsql.upsert('users', values, conflict_on=['email', 'username'])
+    result = tsql.render(query)
+
+    assert "INSERT INTO users" in result[0]
+    assert "ON CONFLICT (email, username)" in result[0]
+    assert "DO UPDATE SET" in result[0]
+    assert "name = EXCLUDED.name" in result[0]
+    assert "email = EXCLUDED.email" not in result[0]
+    assert "username = EXCLUDED.username" not in result[0]
+
+
+def test_upsert_all_conflict_columns():
+    """Test upsert where all columns are conflict columns (should DO NOTHING)"""
+    values = {
+        'email': 'test@example.com'
+    }
+
+    query = tsql.upsert('users', values, conflict_on='email')
+    result = tsql.render(query)
+
+    assert "INSERT INTO users" in result[0]
+    assert "ON CONFLICT (email)" in result[0]
+    assert "DO NOTHING" in result[0]
+    assert "DO UPDATE" not in result[0]
+
+
+def test_delete():
+    """Test the delete helper function"""
+    query = tsql.delete('users', 123)
+    result = tsql.render(query)
+
+    assert "DELETE FROM users" in result[0]
+    assert "WHERE id = ?" in result[0]
+    assert result[1] == [123]
+
+
+def test_delete_string_id():
+    """Test delete with string ID"""
+    query = tsql.delete('users', 'abc-123')
+    result = tsql.render(query)
+
+    assert "DELETE FROM users" in result[0]
+    assert "WHERE id = ?" in result[0]
+    assert result[1] == ['abc-123']

{t_sql-1.1.0 → t_sql-1.2.0}/tests/test_query_builder.py

@@ -1,5 +1,5 @@
 import tsql
-from tsql.query_builder import table, Column, Condition
+from tsql.query_builder import table, Column, Condition, UpdateBuilder, DeleteBuilder
 
 
 @table('users')
@@ -388,3 +388,145 @@ def test_where_with_tstring_complex():
     assert 'WHERE users.id > ?' in sql
     assert 'AND (username ILIKE ? OR email ILIKE ?)' in sql
     assert params == [5, 'john', 'jane']
+
+
+def test_table_insert():
+    """Test table.insert() method"""
+    query = Users.insert({'username': 'bob', 'email': 'bob@example.com'})
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'username' in sql and 'email' in sql
+    assert 'VALUES' in sql
+    assert 'RETURNING *' in sql
+    assert params == ['bob', 'bob@example.com']
+
+
+def test_table_insert_ignore_conflict():
+    """Test table.insert() with ignore_conflict"""
+    query = Users.insert({'username': 'bob', 'email': 'bob@example.com'}, ignore_conflict=True)
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT DO NOTHING' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_upsert():
+    """Test table.upsert() method"""
+    query = Users.upsert({'email': 'bob@example.com', 'username': 'bob'}, conflict_on='email')
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT (email)' in sql
+    assert 'DO UPDATE SET' in sql
+    assert 'username = EXCLUDED.username' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_upsert_with_column_object():
+    """Test table.upsert() with Column object"""
+    query = Users.upsert({'email': 'bob@example.com', 'username': 'bob'}, conflict_on=Users.email)
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT (email)' in sql
+    assert 'DO UPDATE SET' in sql
+    assert 'username = EXCLUDED.username' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_upsert_with_multiple_column_objects():
+    """Test table.upsert() with multiple Column objects"""
+    query = Users.upsert(
+        {'email': 'bob@example.com', 'username': 'bob', 'created_at': '2024-01-01'},
+        conflict_on=[Users.email, Users.username]
+    )
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT (email, username)' in sql
+    assert 'DO UPDATE SET' in sql
+    assert 'created_at = EXCLUDED.created_at' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_update_with_where():
+    """Test table.update() with WHERE clause"""
+    builder = Users.update({'username': 'bob_updated'}).where(Users.id == 5)
+    assert isinstance(builder, UpdateBuilder)
+
+    sql, params = builder.render()
+
+    assert 'UPDATE users SET' in sql
+    assert 'username = ?' in sql
+    assert 'WHERE users.id = ?' in sql
+    assert 'RETURNING *' in sql
+    assert params == ['bob_updated', 5]
+
+
+def test_table_update_multiple_conditions():
+    """Test table.update() with multiple WHERE conditions"""
+    builder = (Users.update({'username': 'bob_updated', 'email': 'new@example.com'})
+               .where(Users.id > 10)
+               .where(Users.created_at == None))
+
+    sql, params = builder.render()
+
+    assert 'UPDATE users SET' in sql
+    assert 'WHERE users.id > ?' in sql
+    assert 'AND users.created_at IS NULL' in sql
+    assert 'RETURNING *' in sql
+    assert params == ['bob_updated', 'new@example.com', 10]
+
+
+def test_table_delete_with_where():
+    """Test table.delete() with WHERE clause"""
+    builder = Users.delete().where(Users.id == 5)
+    assert isinstance(builder, DeleteBuilder)
+
+    sql, params = builder.render()
+
+    assert 'DELETE FROM users' in sql
+    assert 'WHERE users.id = ?' in sql
+    assert 'RETURNING *' in sql
+    assert params == [5]
+
+
+def test_table_delete_multiple_conditions():
+    """Test table.delete() with multiple WHERE conditions"""
+    builder = (Users.delete()
+               .where(Users.id > 100)
+               .where(Users.email == None))
+
+    sql, params = builder.render()
+
+    assert 'DELETE FROM users' in sql
+    assert 'WHERE users.id > ?' in sql
+    assert 'AND users.email IS NULL' in sql
+    assert 'RETURNING *' in sql
+    assert params == [100]
+
+
+def test_update_with_t_string_where():
+    """Test UpdateBuilder with raw t-string WHERE clause"""
+    min_age = 18
+    builder = Users.update({'username': 'adult'}).where(t"age >= {min_age}")
+
+    sql, params = builder.render()
+
+    assert 'UPDATE users SET' in sql
+    assert 'WHERE (age >= ?)' in sql
+    assert params == ['adult', 18]
+
+
+def test_delete_with_t_string_where():
+    """Test DeleteBuilder with raw t-string WHERE clause"""
+    pattern = '%test%'
+    builder = Users.delete().where(t"email LIKE {pattern}")
+
+    sql, params = builder.render()
+
+    assert 'DELETE FROM users' in sql
+    assert 'WHERE (email LIKE ?)' in sql
+    assert params == ['%test%']

{t_sql-1.1.0 → t_sql-1.2.0}/tsql/__init__.py

@@ -72,7 +72,12 @@ class TSQL:
 
     @classmethod
     def _check_literal(cls, val: str):
-        if not isinstance(val, str) or not val.isidentifier():
+        if not isinstance(val, str):
+            raise ValueError(f"Invalid literal {val}")
+
+        # Allow qualified identifiers (table.column, schema.table.column)
+        parts = val.split('.')
+        if not parts or not all(part.isidentifier() for part in parts):
             raise ValueError(f"Invalid literal {val}")
         return val
 
@@ -239,6 +244,68 @@ def update(table: str, values: dict[str, Any], id: str):
 
     if not isinstance(values, dict):
         raise ValueError("values must be a dictionary")
-    
+
     return TSQL(t"UPDATE {table:literal} SET {values:as_set} WHERE id = {id} RETURNING *")
 
+
+def upsert(table: str, values: dict[str, Any], conflict_on: str | list[str]):
+    """Helper function to build INSERT ... ON CONFLICT DO UPDATE (upsert) queries
+
+    Args:
+        table: Table name
+        values: Dictionary of column names and values to insert
+        conflict_on: Column name(s) that define the conflict constraint
+
+    Returns:
+        TSQL object representing the upsert query
+    """
+    if not isinstance(values, dict):
+        raise TypeError("values must be a dict")
+
+    # Normalize conflict_on to a list
+    conflict_cols = [conflict_on] if isinstance(conflict_on, str) else conflict_on
+
+    # Build the conflict target: ON CONFLICT (col1, col2)
+    conflict_target_parts = ['(']
+    for i, col in enumerate(conflict_cols):
+        if i > 0:
+            conflict_target_parts.append(', ')
+        conflict_target_parts.append(col)
+    conflict_target_parts.append(')')
+
+    # Build the UPDATE SET clause with EXCLUDED.* for non-conflict columns
+    update_cols = {k: v for k, v in values.items() if k not in conflict_cols}
+
+    if not update_cols:
+        # If all columns are conflict columns, just do nothing
+        conflict_clause_parts = [' ON CONFLICT '] + conflict_target_parts + [' DO NOTHING']
+    else:
+        update_set_parts = []
+        for i, key in enumerate(update_cols.keys()):
+            if i > 0:
+                update_set_parts.append(', ')
+            update_set_parts.append(key)
+            update_set_parts.append(' = EXCLUDED.')
+            update_set_parts.append(key)
+
+        conflict_clause_parts = [' ON CONFLICT '] + conflict_target_parts + [' DO UPDATE SET '] + update_set_parts
+
+    # Create the conflict clause TSQL object
+    conflict_tsql = TSQL.__new__(TSQL)
+    conflict_tsql._sql_parts = conflict_clause_parts
+
+    return TSQL(t"INSERT INTO {table:literal} {values:as_values}{conflict_tsql} RETURNING *")
+
+
+def delete(table: str, id: str|int):
+    """Helper function to build DELETE queries for a single row
+
+    Args:
+        table: Table name
+        id: ID value to delete
+
+    Returns:
+        TSQL object representing the DELETE query
+    """
+    return TSQL(t"DELETE FROM {table:literal} WHERE id = {id}")
+

{t_sql-1.1.0 → t_sql-1.2.0}/tsql/query_builder.py

@@ -3,7 +3,7 @@ from string.templatelib import Template
 from functools import wraps
 from datetime import datetime
 
-from tsql import TSQL, t_join
+from tsql import TSQL, t_join, insert as tsql_insert, upsert as tsql_upsert, delete as tsql_delete, as_set
 
 # Optional SQLAlchemy support
 try:
@@ -128,6 +128,104 @@ class Join:
         return t'{join_type:unsafe} JOIN {table_name:literal} ON {condition_tsql}'
 
 
+class UpdateBuilder:
+    """Fluent interface for building UPDATE queries"""
+
+    def __init__(self, base_table: 'Table', values: dict[str, Any]):
+        self.base_table = base_table
+        self.values = values
+        self._conditions: List[Union[Condition, Template]] = []
+
+    def where(self, condition: Union[Condition, Template]) -> 'UpdateBuilder':
+        """Add a WHERE condition (multiple calls are ANDed together)"""
+        self._conditions.append(condition)
+        return self
+
+    def to_tsql(self) -> TSQL:
+        """Build the final TSQL object"""
+        parts: List[Template] = []
+
+        table_name = self.base_table.table_name
+        values_dict = self.values
+        parts.append(t'UPDATE {table_name:literal} SET {values_dict:as_set}')
+
+        if self._conditions:
+            where_parts = []
+            for cond in self._conditions:
+                if isinstance(cond, Template):
+                    where_parts.append(t'({cond})')
+                else:
+                    where_parts.append(cond.to_tsql())
+            combined_where = t_join(t' AND ', where_parts)
+            parts.append(t'WHERE {combined_where}')
+
+        parts.append(t'RETURNING *')
+
+        return TSQL(t_join(t' ', parts))
+
+    def render(self, style=None):
+        """Convenience method to render the query directly"""
+        return self.to_tsql().render(style)
+
+    def __repr__(self) -> str:
+        """Show the rendered SQL query for debugging"""
+        try:
+            query, params = self.to_tsql().render()
+            if params:
+                return f"UpdateBuilder(\n  SQL: {query}\n  Params: {params}\n)"
+            return f"UpdateBuilder({query})"
+        except Exception as e:
+            return f"UpdateBuilder(<error rendering: {e}>)"
+
+
+class DeleteBuilder:
+    """Fluent interface for building DELETE queries"""
+
+    def __init__(self, base_table: 'Table'):
+        self.base_table = base_table
+        self._conditions: List[Union[Condition, Template]] = []
+
+    def where(self, condition: Union[Condition, Template]) -> 'DeleteBuilder':
+        """Add a WHERE condition (multiple calls are ANDed together)"""
+        self._conditions.append(condition)
+        return self
+
+    def to_tsql(self) -> TSQL:
+        """Build the final TSQL object"""
+        parts: List[Template] = []
+
+        table_name = self.base_table.table_name
+        parts.append(t'DELETE FROM {table_name:literal}')
+
+        if self._conditions:
+            where_parts = []
+            for cond in self._conditions:
+                if isinstance(cond, Template):
+                    where_parts.append(t'({cond})')
+                else:
+                    where_parts.append(cond.to_tsql())
+            combined_where = t_join(t' AND ', where_parts)
+            parts.append(t'WHERE {combined_where}')
+
+        parts.append(t'RETURNING *')
+
+        return TSQL(t_join(t' ', parts))
+
+    def render(self, style=None):
+        """Convenience method to render the query directly"""
+        return self.to_tsql().render(style)
+
+    def __repr__(self) -> str:
+        """Show the rendered SQL query for debugging"""
+        try:
+            query, params = self.to_tsql().render()
+            if params:
+                return f"DeleteBuilder(\n  SQL: {query}\n  Params: {params}\n)"
+            return f"DeleteBuilder({query})"
+        except Exception as e:
+            return f"DeleteBuilder(<error rendering: {e}>)"
+
+
 class QueryBuilder:
     """Fluent interface for building SQL queries"""
 
@@ -374,7 +472,60 @@ def table(name: str, *, metadata: Optional[Any] = None, schema: Optional[str] =
                 builder.select(*columns)
             return builder
 
+        def insert(self, values: dict[str, Any], ignore_conflict: bool = False) -> TSQL:
+            """Insert a row into the table
+
+            Args:
+                values: Dictionary of column names and values
+                ignore_conflict: If True, adds ON CONFLICT DO NOTHING
+
+            Returns:
+                TSQL object representing the INSERT query
+            """
+            return tsql_insert(self.table_name, values, ignore_conflict=ignore_conflict)
+
+        def upsert(self, values: dict[str, Any], conflict_on: str | list[str] | Column | list[Column]) -> TSQL:
+            """Upsert (INSERT ... ON CONFLICT DO UPDATE) a row
+
+            Args:
+                values: Dictionary of column names and values
+                conflict_on: Column name(s) or Column object(s) that define the conflict constraint
+
+            Returns:
+                TSQL object representing the UPSERT query
+            """
+            # Convert Column objects to strings
+            if isinstance(conflict_on, Column):
+                conflict_on = conflict_on.column_name
+            elif isinstance(conflict_on, list):
+                conflict_on = [col.column_name if isinstance(col, Column) else col for col in conflict_on]
+
+            return tsql_upsert(self.table_name, values, conflict_on=conflict_on)
+
+        def update(self, values: dict[str, Any]) -> UpdateBuilder:
+            """Start building an UPDATE query
+
+            Args:
+                values: Dictionary of column names and values to update
+
+            Returns:
+                UpdateBuilder for adding WHERE conditions
+            """
+            return UpdateBuilder(self, values)
+
+        def delete(self) -> DeleteBuilder:
+            """Start building a DELETE query
+
+            Returns:
+                DeleteBuilder for adding WHERE conditions
+            """
+            return DeleteBuilder(self)
+
         cls.select = select
+        cls.insert = insert
+        cls.upsert = upsert
+        cls.update = update
+        cls.delete = delete
 
         # Return an instance instead of the class
         return cls()