Allow for nested templates

This allows for a template to be specified as a value as allows for
complex query parts to be added/removed as desired.

Author: pgjones

src/sql_tstring/__init__.py

@@ -16,7 +16,7 @@
     Group,
     Literal,
     Operator,
-    parse_template,
+    parse,
     Part,
     Placeholder,
     PlaceholderType,
@@ -95,7 +95,7 @@ def sql(
     else:
         raise ValueError("Must call with a template, or a query string and values")
 
-    parsed_queries = parse_template(template)
+    parsed_queries = parse(template)
     result_str = ""
     result_values: list[typing.Any] = []
     ctx = get_context()

src/sql_tstring/parser.py

@@ -5,6 +5,8 @@
 from enum import auto, Enum, unique
 from typing import cast
 
+from sql_tstring.t import Template as TTemplate
+
 try:
     from string.templatelib import Interpolation, Template  # type: ignore[import-untyped]
 except ImportError:
@@ -323,19 +325,24 @@ class Operator:
 type Element = Node | Operator | Part | Placeholder
 
 
-def parse_template(template: Template) -> list[Statement]:
+def parse(template: Template) -> list[Statement]:
     statements = [Statement()]
     current_node: Node = statements[0]
+    _parse_template(template, current_node, statements)
+    return statements
+
 
+def _parse_template(template: Template, current_node: Node, statements: list[Statement]) -> None:
     for item in template:
         match item:
             case Interpolation(value, _, _, _):  # type: ignore[misc]
-                _parse_placeholder(current_node, value)
+                if isinstance(value, (Template, TTemplate)):
+                    _parse_template(value, current_node, statements)
+                else:
+                    _parse_placeholder(current_node, value)
             case str() as raw:
                 current_node = _parse_string(raw, current_node, statements)
 
-    return statements
-
 
 def _parse_placeholder(
     current_node: Node,

tests/test_parameters.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from sql_tstring import RewritingValue, sql, sql_context
+from sql_tstring import RewritingValue, sql, sql_context, t
 
 TZ = "uk"
 
@@ -178,3 +178,11 @@ def test_is_null(query: str, expected_query: str, expected_values: list[Any]) ->
 def test_is_not_null(query: str, expected_query: str, expected_values: list[Any]) -> None:
     val = RewritingValue.IS_NOT_NULL
     assert (expected_query, expected_values) == sql(query, locals())
+
+
+def test_nested() -> None:
+    a = "a"
+    inner = t("x = {a}", locals())
+    query, values = sql("SELECT x FROM y WHERE {inner}", locals())
+    assert query == "SELECT x FROM y WHERE x = ?"
+    assert values == ["a"]

tests/test_parsing.py

@@ -1,4 +1,4 @@
-from sql_tstring import sql
+from sql_tstring import sql, t
 
 
 def test_literals() -> None:
@@ -35,7 +35,7 @@ def test_delete_from() -> None:
     assert query == "DELETE FROM y WHERE x = 'NONE'"
 
 
-def test_nested() -> None:
+def test_function() -> None:
     query, _ = sql("SELECT COALESCE(x, now())", locals())
     assert query == "SELECT COALESCE(x , now())"
 
@@ -99,3 +99,9 @@ def test_functional_subquery() -> None:
         locals(),
     )
     assert query == "SELECT x , ARRAY(SELECT a FROM b) FROM y"
+
+
+def test_nested() -> None:
+    inner = t("x = 'a'", locals())
+    query, _ = sql("SELECT x FROM y WHERE {inner}", locals())
+    assert query == "SELECT x FROM y WHERE x = 'a'"