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

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "4.5.0"
+version = "4.5.2"
 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.2}/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.2/tests/test_error_messages.py

@@ -0,0 +1,98 @@
+"""Tests for error message clarity and helpfulness"""
+import pytest
+import tsql
+
+
+def test_literal_non_string_gets_parameterized():
+    """Non-string values with :literal format spec just get parameterized (not an error)"""
+    # This is actually fine behavior - the :literal format spec is ignored for non-strings
+    # and they just get parameterized normally
+    sql, params = tsql.render(t"SELECT * FROM table WHERE id = {123:literal}")
+    assert sql == "SELECT * FROM table WHERE id = ?"
+    assert params == [123]
+
+
+def test_literal_too_many_parts_error():
+    """Too many parts should show expected count and list all parts"""
+    table = "a.b.c.d"
+    with pytest.raises(ValueError) as exc_info:
+        tsql.render(t"SELECT * FROM {table:literal}")
+
+    error_msg = str(exc_info.value)
+    assert "too many parts" in error_msg
+    assert "expected at most 3" in error_msg
+    assert "got 4" in error_msg
+    assert "'a'" in error_msg and "'b'" in error_msg and "'c'" in error_msg and "'d'" in error_msg
+
+
+def test_literal_empty_string_error():
+    """Empty string should explain it's not a valid identifier and show examples"""
+    table = ""
+    with pytest.raises(ValueError) as exc_info:
+        tsql.render(t"SELECT * FROM {table:literal}")
+
+    error_msg = str(exc_info.value)
+    assert "empty string is not a valid identifier" in error_msg
+    assert "users" in error_msg or "public.users" in error_msg  # Should show examples
+
+
+def test_literal_invalid_identifier_error():
+    """Invalid identifiers should show which parts are invalid and explain rules"""
+    table = "my-table"  # Hyphens not allowed
+    with pytest.raises(ValueError) as exc_info:
+        tsql.render(t"SELECT * FROM {table:literal}")
+
+    error_msg = str(exc_info.value)
+    assert "invalid identifier" in error_msg
+    assert "'my-table'" in error_msg
+    assert "valid Python identifier" in error_msg
+    assert "letters, digits, underscores" in error_msg
+
+
+def test_literal_starts_with_digit_error():
+    """Identifiers starting with digits should be caught with helpful message"""
+    table = "123users"
+    with pytest.raises(ValueError) as exc_info:
+        tsql.render(t"SELECT * FROM {table:literal}")
+
+    error_msg = str(exc_info.value)
+    assert "invalid identifier" in error_msg
+    assert "'123users'" in error_msg
+    assert "valid Python identifier" in error_msg
+
+
+def test_literal_special_chars_error():
+    """Special characters should be caught and suggest :unsafe if needed"""
+    table = "users@prod"  # @ not allowed
+    with pytest.raises(ValueError) as exc_info:
+        tsql.render(t"SELECT * FROM {table:literal}")
+
+    error_msg = str(exc_info.value)
+    assert "invalid identifier" in error_msg
+    assert "'users@prod'" in error_msg
+    assert ":unsafe" in error_msg  # Suggests alternative
+
+
+def test_literal_qualified_name_with_invalid_part():
+    """Qualified names with one invalid part should identify which part is bad"""
+    table = "public.my-table"  # Second part has hyphen
+    with pytest.raises(ValueError) as exc_info:
+        tsql.render(t"SELECT * FROM {table:literal}")
+
+    error_msg = str(exc_info.value)
+    assert "invalid identifier" in error_msg
+    assert "'my-table'" in error_msg  # Should identify the bad part
+    # Should NOT complain about 'public' since it's valid
+
+
+def test_literal_sql_keyword_suggestion():
+    """Error for SQL keywords should suggest :unsafe workaround"""
+    # Note: SQL keywords like 'select' are actually valid Python identifiers,
+    # so this tests the general suggestion about :unsafe for special cases
+    table = "table-name"
+    with pytest.raises(ValueError) as exc_info:
+        tsql.render(t"SELECT * FROM {table:literal}")
+
+    error_msg = str(exc_info.value)
+    assert ":unsafe" in error_msg
+    assert "caution" in error_msg

{t_sql-4.5.0 → t_sql-4.5.2}/tests/test_query_builder.py

@@ -1378,3 +1378,56 @@ def test_delete_with_all_rows_works():
     assert 'DELETE FROM users' in sql
     assert 'WHERE' not in sql
     assert params == []
+
+
+def test_nested_querybuilder_in_tstring():
+    """Test that QueryBuilder can be interpolated into t-strings as subqueries"""
+    # Create a subquery
+    subquery = Posts.select(Posts.user_id).where(Posts.id == 42)
+
+    # Interpolate it into a regular t-string
+    query = tsql.TSQL(t'SELECT *, ({subquery}) as post_user FROM users')
+    sql, params = query.render()
+
+    # The subquery SQL should be inlined, not parameterized
+    assert 'SELECT *,' in sql
+    assert 'SELECT posts.user_id FROM posts WHERE posts.id = ?' in sql
+    assert 'as post_user FROM users' in sql
+    # The parameter from the subquery should be in the params list
+    assert params == [42]
+
+
+def test_nested_querybuilder_with_multiple_params():
+    """Test nested QueryBuilder with multiple parameters from both queries"""
+    # Create a subquery with a parameter
+    subquery = Posts.select(Posts.id).where(Posts.user_id == 100)
+
+    # Use it in a main query that also has parameters
+    query = tsql.TSQL(t'SELECT * FROM users WHERE id = {5} AND post_count > ({subquery})')
+    sql, params = query.render()
+
+    # Both parameters should be in the list
+    assert params == [5, 100]
+    # The subquery should be inlined
+    assert 'SELECT posts.id FROM posts WHERE posts.user_id = ?' in sql
+
+
+def test_nested_querybuilder_with_different_styles():
+    """Test that nested QueryBuilders work with different parameter styles"""
+    from tsql.styles import NUMERIC_DOLLAR, NAMED
+
+    subquery = Posts.select(Posts.user_id).where(Posts.id == 42)
+
+    # Test with NUMERIC_DOLLAR style
+    query = tsql.TSQL(t'SELECT *, ({subquery}) as post_user FROM users WHERE id = {5}')
+    sql, params = query.render(style=NUMERIC_DOLLAR)
+    assert '$1' in sql and '$2' in sql
+    assert params == [42, 5]
+
+    # Test with NAMED style
+    sql, params = query.render(style=NAMED)
+    # Check that both parameters are present (names may vary)
+    assert isinstance(params, dict)
+    assert len(params) == 2
+    assert 42 in params.values() and 5 in params.values()
+    assert 'SELECT posts.user_id FROM posts WHERE posts.id = :' in sql

t_sql-4.5.2/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.2}/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.2}/tsql/__init__.py

@@ -1,10 +1,17 @@
 import re
 import string
+import datetime
+import logging
 from typing import NamedTuple, Tuple, Any, List, Dict, Iterable, Union, TYPE_CHECKING
 from string.templatelib import Template, Interpolation
 
 from tsql.styles import ParamStyle, QMARK
 
+logger = logging.getLogger(__name__)
+
+# Pre-compile regex for whitespace collapsing to avoid cache lookup overhead
+_WHITESPACE_RE = re.compile(r'\s+')
+
 if TYPE_CHECKING:
     from tsql.query_builder import QueryBuilder
 
@@ -12,6 +19,7 @@ default_style = QMARK
 
 def set_style(style: type[ParamStyle]):
     global default_style
+    logger.debug("Setting default parameter style to: %s", style.__name__)
     default_style = style
 
 
@@ -49,6 +57,7 @@ class TSQL:
     def render(self, style:ParamStyle = None) -> RenderedQuery:
         if style is None:
             style = default_style
+        logger.debug("Rendering query with style: %s", style.__name__)
         result = ''
 
         style_instance = style()
@@ -60,6 +69,8 @@ class TSQL:
             else:
                 result += part
 
+        logger.debug("Rendered SQL: %s", result)
+        logger.debug("Parameters (%d): %s", len(style_instance.params), style_instance.params)
         return RenderedQuery(result, style_instance.params)
 
 
@@ -74,16 +85,34 @@ class TSQL:
     @classmethod
     def _check_literal(cls, val: str):
         if not isinstance(val, str):
-            raise ValueError(f"Invalid literal {val}")
+            raise ValueError(
+                f"Invalid literal {val!r}: literals must be strings, got {type(val).__name__}. "
+                f"Use {{value}} without :literal to parameterize non-string values."
+            )
 
         # Allow qualified identifiers (table.column, schema.table.column)
         parts = val.split('.')
 
         if len(parts) > 3:
-            raise ValueError(f"Invalid literal {val}: too many parts (max 3 for schema.table.column)")
-
-        if not parts or not all(part.isidentifier() for part in parts):
-            raise ValueError(f"Invalid literal {val}")
+            raise ValueError(
+                f"Invalid literal {val!r}: too many parts (expected at most 3 for schema.table.column, got {len(parts)}). "
+                f"Parts: {', '.join(repr(p) for p in parts)}"
+            )
+
+        # Check for empty string or empty parts
+        if not val or any(not p for p in parts):
+            raise ValueError(
+                f"Invalid literal {val!r}: empty string is not a valid identifier. "
+                f"Literals must be valid Python identifiers (e.g., 'users', 'public.users', 'schema.table.column')."
+            )
+
+        invalid_parts = [p for p in parts if not p.isidentifier()]
+        if invalid_parts:
+            raise ValueError(
+                f"Invalid literal {val!r}: contains invalid identifier(s): {', '.join(repr(p) for p in invalid_parts)}. "
+                f"Each part must be a valid Python identifier (letters, digits, underscores; cannot start with digit). "
+                f"If you need special characters or SQL keywords, consider using {{value:unsafe}} with caution."
+            )
         return val
 
     @classmethod
@@ -95,11 +124,17 @@ class TSQL:
             if val.conversion:
                 value = formatter.convert_field(value, val.conversion)
 
+            logger.debug("Processing interpolation: expression=%r, format_spec=%r, value_type=%s",
+                        val.expression, val.format_spec, type(value).__name__)
+
             match val.format_spec, value:
                 case 'literal', str():
+                    logger.debug("Validating literal: %r", value)
                     cls._check_literal(value)
+                    logger.debug("Literal validated, inlining: %r", value)
                     return [value]
                 case 'unsafe', str():
+                    logger.debug("Using unsafe inline value: %r", value)
                     return [value]
                 case 'as_values', dict():
                     return as_values(value)._sql_parts
@@ -109,6 +144,9 @@ class TSQL:
                     return val.value._sql_parts
                 case "", Template():
                     return TSQL(value)._sql_parts
+                case '', x if hasattr(x, 'to_tsql'):
+                    logger.debug("Inlining QueryBuilder object: %s", type(x).__name__)
+                    return x.to_tsql()._sql_parts
                 case '', None:
                     return [Parameter(val.expression, None)]
                 # case 'as_array', list():
@@ -127,6 +165,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))]
 
@@ -136,7 +176,7 @@ class TSQL:
                 if isinstance(item, Interpolation):
                     result.extend(cls._sqlize(item))
                 else:
-                    result.append(re.sub(r'\s+', ' ', item))
+                    result.append(_WHITESPACE_RE.sub(' ', item))
             return result
 
         raise ValueError(f"UNSAFE {val}") # this shouldnt happen and is for debugging
@@ -179,7 +219,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 +261,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.2}/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}')