t-sql 4.8.0__tar.gz → 4.9.1__tar.gz

{t_sql-4.8.0 → t_sql-4.9.1}/PKG-INFO

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

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

{t_sql-4.8.0 → t_sql-4.9.1}/tests/test_query_builder.py

@@ -116,6 +116,19 @@ def test_select_specific_columns():
     assert params == []
 
 
+def test_multiple_select_calls_append():
+    """Test that multiple .select() calls append columns instead of replacing them"""
+    query = Users.select(Users.id)
+    query.select(Users.username, Users.email)
+    sql, params = query.render()
+
+    # All three columns should be present
+    assert 'users.id' in sql
+    assert 'users.username' in sql
+    assert 'users.email' in sql
+    assert params == []
+
+
 def test_select_with_where():
     """Test SELECT with WHERE clause"""
     query = Users.select(Users.id, Users.username).where(Users.id == 5)
@@ -1431,3 +1444,104 @@ def test_nested_querybuilder_with_different_styles():
     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
+
+
+# CTE Tests
+
+def test_basic_cte():
+    """Test basic CTE with query builder"""
+    from tsql.query_builder import SelectQueryBuilder
+
+    query = (
+        SelectQueryBuilder.from_table('active_users')
+        .with_cte('active_users', Users.select(Users.id, Users.username).where(Users.email == 'test@example.com'))
+        .select('id', 'username')
+    )
+
+    sql, params = query.render()
+    assert sql == "WITH active_users AS (SELECT users.id, users.username FROM users WHERE users.email = ?) SELECT id, username FROM active_users"
+    assert params == ['test@example.com']
+
+
+def test_cte_with_tstring():
+    """Test CTE with raw t-string query"""
+    from tsql.query_builder import SelectQueryBuilder
+
+    query = (
+        SelectQueryBuilder.from_table('counts')
+        .with_cte('counts', t'SELECT COUNT(*) as total FROM users')
+        .select('total')
+    )
+
+    sql, _ = query.render()
+    assert "WITH counts AS (SELECT COUNT(*) as total FROM users)" in sql
+    assert "SELECT total FROM counts" in sql
+
+
+def test_multiple_ctes():
+    """Test chaining multiple CTEs"""
+    from tsql.query_builder import SelectQueryBuilder
+
+    query = (
+        SelectQueryBuilder.from_table('filtered')
+        .with_cte('jennifers', Users.select(Users.id, Users.username).where(Users.username == 'Jennifer'))
+        .with_cte('filtered', t'SELECT id FROM jennifers WHERE id > 18')
+    )
+
+    sql, _ = query.render()
+    assert "WITH jennifers AS" in sql
+    assert ", filtered AS" in sql
+    assert "SELECT * FROM filtered" in sql
+
+
+def test_recursive_cte():
+    """Test recursive CTE with t-string"""
+    from tsql.query_builder import SelectQueryBuilder
+
+    query = (
+        SelectQueryBuilder.from_table('category_tree')
+        .with_cte('category_tree', t'''
+            SELECT id, name, parent_id, 1 as level
+            FROM categories
+            WHERE parent_id IS NULL
+            UNION ALL
+            SELECT c.id, c.name, c.parent_id, ct.level + 1
+            FROM categories c
+            JOIN category_tree ct ON c.parent_id = ct.id
+        ''', recursive=True)
+    )
+
+    sql, _ = query.render()
+    assert sql.startswith("WITH RECURSIVE category_tree AS")
+    assert "SELECT * FROM category_tree" in sql
+
+
+def test_cte_name_validation():
+    """Test CTE name is validated as identifier"""
+    from tsql.query_builder import SelectQueryBuilder
+    import pytest
+
+    query = SelectQueryBuilder.from_table('test')
+
+    with pytest.raises(ValueError, match="Invalid CTE name"):
+        query.with_cte('invalid-name', t'SELECT 1')
+
+    with pytest.raises(ValueError, match="Invalid CTE name"):
+        query.with_cte('123start', t'SELECT 1')
+
+
+def test_multiple_recursive_ctes():
+    """Test multiple CTEs where one is recursive"""
+    from tsql.query_builder import SelectQueryBuilder
+
+    query = (
+        SelectQueryBuilder.from_table('result')
+        .with_cte('normal', t'SELECT id FROM users')
+        .with_cte('tree', t'SELECT id FROM tree UNION ALL SELECT id+1 FROM tree WHERE id < 10', recursive=True)
+    )
+
+    sql, _ = query.render()
+    # Should use WITH RECURSIVE if ANY CTE is recursive
+    assert sql.startswith("WITH RECURSIVE")
+    assert "normal AS" in sql
+    assert "tree AS" in sql

{t_sql-4.8.0 → t_sql-4.9.1}/tsql/query_builder.py

@@ -1161,6 +1161,7 @@ class SelectQueryBuilder(QueryBuilder):
         self._order_by_columns: List[tuple[Union[Column, str], str]] = []
         self._limit_value: Optional[int] = None
         self._offset_value: Optional[int] = None
+        self._ctes: List[tuple[str, Union[Template, TSQL, 'SelectQueryBuilder'], bool]] = []
 
     @classmethod
     def from_table(cls, table_name: str, schema: Optional[str] = None) -> 'SelectQueryBuilder':
@@ -1200,7 +1201,13 @@ class SelectQueryBuilder(QueryBuilder):
             # No columns specified selects all (SELECT *)
             users.select()
         """
-        self._columns = list(columns) if columns else None
+        if columns:
+            if self._columns is None:
+                self._columns = []
+            self._columns.extend(columns)
+        else:
+            # Calling select() with no args resets to SELECT *
+            self._columns = None
         return self
 
     def where(self, condition: Union[Condition, Template]) -> 'SelectQueryBuilder':
@@ -1283,10 +1290,85 @@ class SelectQueryBuilder(QueryBuilder):
         self._offset_value = n
         return self
 
+    def with_cte(self, name: str,
+                 query: Union[Template, TSQL, 'SelectQueryBuilder'],
+                 recursive: bool = False) -> 'SelectQueryBuilder':
+        """Add a CTE to this query's WITH clause.
+
+        Multiple CTEs can be chained by calling this method multiple times.
+
+        Args:
+            name: CTE name (validated as valid identifier)
+            query: The CTE query (SelectQueryBuilder, t-string Template, or TSQL)
+            recursive: Whether this CTE is recursive (adds RECURSIVE keyword)
+
+        Returns:
+            Self for method chaining
+
+        Example:
+            # Basic CTE
+            query = (
+                SelectQueryBuilder.from_table('active_users')
+                .with_cte('active_users', Users.select().where(Users.active == True))
+                .select('id', 'name')
+            )
+
+            # Multiple CTEs
+            query = (
+                SelectQueryBuilder.from_table('filtered')
+                .with_cte('jennifers', Users.select().where(...))
+                .with_cte('filtered', t'SELECT id FROM jennifers WHERE age > 18')
+                .select('*')
+            )
+
+            # Recursive CTE
+            query = (
+                SelectQueryBuilder.from_table('tree')
+                .with_cte('tree', t'''
+                    SELECT id, name, parent_id FROM categories WHERE parent_id IS NULL
+                    UNION ALL
+                    SELECT c.id, c.name, c.parent_id FROM categories c
+                    JOIN tree t ON c.parent_id = t.id
+                ''', recursive=True)
+                .select('*')
+            )
+        """
+        if not name.isidentifier():
+            raise ValueError(f"Invalid CTE name: {name!r}. Must be a valid Python identifier.")
+
+        self._ctes.append((name, query, recursive))
+        return self
+
     def to_tsql(self) -> TSQL:
         """Build the final TSQL object"""
         parts: List[Template] = []
 
+        # Render CTEs if present
+        if self._ctes:
+            has_recursive = any(recursive for _, _, recursive in self._ctes)
+            cte_parts = []
+
+            for name, query, _ in self._ctes:
+                # Convert CTE query to TSQL
+                if hasattr(query, 'to_tsql'):
+                    cte_sql = query.to_tsql()
+                elif isinstance(query, Template):
+                    cte_sql = TSQL(query)
+                else:
+                    cte_sql = query
+
+                # Render as: cte_name AS (query)
+                cte_parts.append(t'{name:literal} AS ({cte_sql})')
+
+            # Join all CTEs with commas
+            cte_clause = t_join(t', ', cte_parts)
+
+            # Add WITH or WITH RECURSIVE
+            if has_recursive:
+                parts.append(t'WITH RECURSIVE {cte_clause}')
+            else:
+                parts.append(t'WITH {cte_clause}')
+
         if self._columns:
             # Build column list, handling Column objects, Template (t-string) objects, and strings
             column_parts = []