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

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "4.5.1"
+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.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.1 → 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.1 → t_sql-4.5.2}/tsql/__init__.py

@@ -1,11 +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
 
@@ -13,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
 
 
@@ -50,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()
@@ -61,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)
 
 
@@ -75,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
@@ -96,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
@@ -110,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():
@@ -139,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