sqlspec 0.24.0__tar.gz → 0.24.1__tar.gz

{sqlspec-0.24.0 → sqlspec-0.24.1}/.pre-commit-config.yaml

@@ -17,7 +17,7 @@ repos:
       - id: mixed-line-ending
       - id: trailing-whitespace
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.12.12"
+    rev: "v0.13.0"
     hooks:
       - id: ruff
         args: ["--fix"]

{sqlspec-0.24.0 → sqlspec-0.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.24.0
+Version: 0.24.1
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.24.0 → sqlspec-0.24.1}/pyproject.toml

@@ -13,7 +13,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.9, <4.0"
-version = "0.24.0"
+version = "0.24.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"

{sqlspec-0.24.0 → sqlspec-0.24.1}/sqlspec/_sql.py

@@ -137,21 +137,18 @@ class SQLFactory:
         self.dialect = dialect
 
     def __call__(self, statement: str, dialect: DialectType = None) -> "Any":
-        """Create a SelectBuilder from a SQL string, only allowing SELECT/CTE queries.
+        """Create a SelectBuilder from a SQL string, or SQL object for DML with RETURNING.
 
         Args:
             statement: The SQL statement string.
-            parameters: Optional parameters for the query.
-            *filters: Optional filters.
-            config: Optional config.
             dialect: Optional SQL dialect.
-            **kwargs: Additional parameters.
 
         Returns:
-            SelectBuilder instance.
+            SelectBuilder instance for SELECT/WITH statements,
+            SQL object for DML statements with RETURNING clause.
 
         Raises:
-            SQLBuilderError: If the SQL is not a SELECT/CTE statement.
+            SQLBuilderError: If the SQL is not a SELECT/CTE/DML+RETURNING statement.
         """
 
         try:
@@ -175,8 +172,13 @@ class SQLFactory:
             builder = Select(dialect=dialect or self.dialect)
             builder._expression = parsed_expr
             return builder
+
+        if actual_type_str in {"INSERT", "UPDATE", "DELETE"} and parsed_expr.args.get("returning") is not None:
+            return SQL(statement)
+
         msg = (
-            f"sql(...) only supports SELECT statements. Detected type: {actual_type_str}. "
+            f"sql(...) only supports SELECT statements or DML statements with RETURNING clause. "
+            f"Detected type: {actual_type_str}. "
             f"Use sql.{actual_type_str.lower()}() instead."
         )
         raise SQLBuilderError(msg)

{sqlspec-0.24.0 → sqlspec-0.24.1}/tests/unit/test_sql_factory.py

@@ -1575,3 +1575,166 @@ def test_querybuilder_parameter_conversion_preserves_functionality() -> None:
     assert len(complex_stmt.parameters) == 2
     assert "2023-01-01" in complex_stmt.parameters.values()
     assert "click" in complex_stmt.parameters.values()
+
+
+def test_sql_call_with_update_returning() -> None:
+    """Test that sql() accepts UPDATE statements with RETURNING clause."""
+    update_sql = "UPDATE books SET title = :title, pages = :pages WHERE id = :id RETURNING *"
+    query = sql(update_sql)
+
+    assert isinstance(query, SQL)
+    assert query.returns_rows()
+    assert "UPDATE" in query.sql.upper()
+    assert "RETURNING" in query.sql.upper()
+
+
+def test_sql_call_with_insert_returning() -> None:
+    """Test that sql() accepts INSERT statements with RETURNING clause."""
+    insert_sql = "INSERT INTO books (title, pages) VALUES (:title, :pages) RETURNING id, title"
+    query = sql(insert_sql)
+
+    assert isinstance(query, SQL)
+    assert query.returns_rows()
+    assert "INSERT" in query.sql.upper()
+    assert "RETURNING" in query.sql.upper()
+
+
+def test_sql_call_with_delete_returning() -> None:
+    """Test that sql() accepts DELETE statements with RETURNING clause."""
+    delete_sql = "DELETE FROM books WHERE id = :id RETURNING id, title"
+    query = sql(delete_sql)
+
+    assert isinstance(query, SQL)
+    assert query.returns_rows()
+    assert "DELETE" in query.sql.upper()
+    assert "RETURNING" in query.sql.upper()
+
+
+def test_sql_call_rejects_update_without_returning() -> None:
+    """Test that sql() rejects UPDATE statements without RETURNING clause."""
+    update_sql = "UPDATE books SET title = :title WHERE id = :id"
+
+    with pytest.raises(SQLBuilderError) as exc_info:
+        sql(update_sql)
+
+    assert "only supports SELECT statements or DML statements with RETURNING clause" in str(exc_info.value)
+    assert "UPDATE" in str(exc_info.value)
+
+
+def test_sql_call_rejects_insert_without_returning() -> None:
+    """Test that sql() rejects INSERT statements without RETURNING clause."""
+    insert_sql = "INSERT INTO books (title, pages) VALUES (:title, :pages)"
+
+    with pytest.raises(SQLBuilderError) as exc_info:
+        sql(insert_sql)
+
+    assert "only supports SELECT statements or DML statements with RETURNING clause" in str(exc_info.value)
+    assert "INSERT" in str(exc_info.value)
+
+
+def test_sql_call_rejects_delete_without_returning() -> None:
+    """Test that sql() rejects DELETE statements without RETURNING clause."""
+    delete_sql = "DELETE FROM books WHERE id = :id"
+
+    with pytest.raises(SQLBuilderError) as exc_info:
+        sql(delete_sql)
+
+    assert "only supports SELECT statements or DML statements with RETURNING clause" in str(exc_info.value)
+    assert "DELETE" in str(exc_info.value)
+
+
+def test_sql_update_method_with_returning() -> None:
+    """Test that sql.update() returns Update builder for statements with RETURNING (use sql() for SQL object)."""
+    from sqlspec.builder import Update
+
+    update_sql = "UPDATE books SET title = :title WHERE id = :id RETURNING *"
+    query = sql.update(update_sql)
+
+    assert isinstance(query, Update)
+    # For RETURNING statements, use sql() instead to get SQL object
+    sql_query = sql(update_sql)
+    assert isinstance(sql_query, SQL)
+    assert sql_query.returns_rows()
+
+
+def test_sql_insert_method_with_returning() -> None:
+    """Test that sql.insert() returns Insert builder for statements with RETURNING (use sql() for SQL object)."""
+    from sqlspec.builder import Insert
+
+    insert_sql = "INSERT INTO books (title) VALUES (:title) RETURNING id, title"
+    query = sql.insert(insert_sql)
+
+    assert isinstance(query, Insert)
+    # For RETURNING statements, use sql() instead to get SQL object
+    sql_query = sql(insert_sql)
+    assert isinstance(sql_query, SQL)
+    assert sql_query.returns_rows()
+
+
+def test_sql_delete_method_with_returning() -> None:
+    """Test that sql.delete() returns Delete builder for statements with RETURNING (use sql() for SQL object)."""
+    from sqlspec.builder import Delete
+
+    delete_sql = "DELETE FROM books WHERE id = :id RETURNING *"
+    query = sql.delete(delete_sql)
+
+    assert isinstance(query, Delete)
+    # For RETURNING statements, use sql() instead to get SQL object
+    sql_query = sql(delete_sql)
+    assert isinstance(sql_query, SQL)
+    assert sql_query.returns_rows()
+
+
+def test_sql_update_method_without_returning_returns_builder() -> None:
+    """Test that sql.update() returns Update builder for statements without RETURNING."""
+    from sqlspec.builder import Update
+
+    update_sql = "UPDATE books SET title = :title WHERE id = :id"
+    query = sql.update(update_sql)
+
+    assert isinstance(query, Update)
+    assert not isinstance(query, SQL)
+
+
+def test_sql_insert_method_without_returning_returns_builder() -> None:
+    """Test that sql.insert() returns Insert builder for statements without RETURNING."""
+    from sqlspec.builder import Insert
+
+    insert_sql = "INSERT INTO books (title) VALUES (:title)"
+    query = sql.insert(insert_sql)
+
+    assert isinstance(query, Insert)
+    assert not isinstance(query, SQL)
+
+
+def test_sql_delete_method_without_returning_returns_builder() -> None:
+    """Test that sql.delete() returns Delete builder for statements without RETURNING."""
+    from sqlspec.builder import Delete
+
+    delete_sql = "DELETE FROM books WHERE id = :id"
+    query = sql.delete(delete_sql)
+
+    assert isinstance(query, Delete)
+    assert not isinstance(query, SQL)
+
+
+def test_select_statements_still_work_with_sql_call() -> None:
+    """Test that SELECT statements continue to work with sql()."""
+    from sqlspec.builder import Select
+
+    select_sql = "SELECT * FROM books WHERE id = :id"
+    query = sql(select_sql)
+
+    assert isinstance(query, Select)
+    assert not isinstance(query, SQL)
+
+
+def test_with_statements_still_work_with_sql_call() -> None:
+    """Test that WITH statements continue to work with sql()."""
+    from sqlspec.builder import Select
+
+    with_sql = "WITH ranked AS (SELECT *, ROW_NUMBER() OVER (ORDER BY id) as rn FROM books) SELECT * FROM ranked"
+    query = sql(with_sql)
+
+    assert isinstance(query, Select)
+    assert not isinstance(query, SQL)

{sqlspec-0.24.0 → sqlspec-0.24.1}/tests/unit/test_utils/test_correlation.py

@@ -270,7 +270,7 @@ def test_adapter_with_empty_extra() -> None:
 
     CorrelationContext.set("test-id")
 
-    msg, kwargs = adapter.process("Test message", {"extra": {}})
+    _msg, kwargs = adapter.process("Test message", {"extra": {}})
 
     assert kwargs["extra"]["correlation_id"] == "test-id"
 

{sqlspec-0.24.0 → sqlspec-0.24.1}/tests/unit/test_utils/test_type_guards.py

@@ -695,7 +695,7 @@ def test_extract_dataclass_fields_conflicting_include_exclude() -> None:
     """Test extract_dataclass_fields raises error for conflicting include/exclude."""
     instance = SampleDataclass(name="test", age=25)
 
-    with pytest.raises(ValueError, match="Fields .* are both included and excluded"):
+    with pytest.raises(ValueError, match="Fields .* are both included and excluded"):  # noqa: RUF043
         extract_dataclass_fields(instance, include={"name"}, exclude={"name"})