sql_querystring_builder 0.3.0__tar.gz → 0.4.0__tar.gz

{sql_querystring_builder-0.3.0/src/sql_querystring_builder.egg-info → sql_querystring_builder-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_querystring_builder
-Version: 0.3.0
+Version: 0.4.0
 Summary: Wraps string building of MS SQL queries
 Author-email: Wael GRIBAA <g.wael@outlook.fr>
 License-Expression: GPL-3.0-only
@@ -35,6 +35,8 @@ It provides first level validation.
 2. Using:
     - [x] Select (with DISTINCT and TOP)
     - [x] Update (with typed values)
+    - [x] Insert (multi-row VALUES)
+    - [x] Delete (with joins; refused without a WHERE unless asked)
     - [x] From
     - [x] InnerJoin, LeftJoin, RightJoin, FullJoin (on two fields or on any condition), CrossJoin
     - [x] Where (with conditions)
@@ -47,7 +49,6 @@ It provides first level validation.
 
 ## Not implemented (yet)
 In planned order:
-- [ ] Insert and Delete
 - [ ] Functions (aggregates and others), GROUP BY, HAVING, CASE
 - [ ] Compound queries (UNION, INTERSECT, EXCEPT) and sub-queries
 
@@ -134,6 +135,23 @@ print(params)
 # > (20000, 'A1C%')
 # With pyodbc: cursor.execute(sql, params). For pymssql, build_with_params("format") writes %s instead.
 ```
+6. Insert and delete rows:
+```
+# Inserts rows: one tuple per row, with the values in column order
+insert = Insert(customers_table.fields.customerId, customers_table.fields.mainPhone).values(
+    ("A1C42", "555-0100"), ("B7", None)
+)
+print(QueryBuilder(insert).build())
+# > INSERT INTO Customers (customerId, mainPhone)
+# > VALUES ('A1C42', '555-0100'), ('B7', NULL)
+
+# Deletes the accounts of customer B7; a DELETE needs a WHERE, unless built with where_required=False
+delete = QueryBuilder(Delete(accounts_table), From(accounts_table), Where(accounts_table.fields.customerId.eq("B7")))
+print(delete.build())
+# > DELETE acc
+# > FROM Accounts acc
+# > WHERE acc.customerId = 'B7'
+```
 
 (Find it directly in the module example.py)
 
@@ -144,6 +162,19 @@ Python 3.10 and above.
 (None)
 
 ## Changelog
+### 0.4.0
+Queries built with 0.3.0 produce the same SQL.
+- `Insert(*columns).values(*rows)` renders `INSERT INTO Customers (id, name)` and
+  `VALUES (1, 'Ann'), (2, 'O''Brien')`. The columns are fields of one table, or a whole table. Each row is a
+  tuple of values in column order, with at most 1000 rows per INSERT, as in T-SQL. Values are escaped as in
+  conditions, plain strings included, and `Raw("DEFAULT")` writes SQL. An Insert stands alone in its query.
+- `Delete(table)` renders `DELETE` and the table's alias, or its name, and works with `From`, joins and
+  `Where`: `DELETE acc FROM Accounts acc INNER JOIN ...`. A query with a DELETE but no WHERE raises
+  `IncompatibleClausesException`, unless written `Delete(table, where_required=False)`; so does a DELETE with
+  ORDER BY.
+- Both work with `build_with_params()`. SQL Server accepts about 2,100 parameters per query, so split big
+  parameterized inserts.
+
 ### 0.3.0
 Queries built with 0.2.0 produce the same SQL, except for the fixed `Update` values below.
 - Conditions are methods of fields, functions on fields and strings: `eq`, `ne`, `lt`, `le`, `gt`, `ge`,

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/README.md

@@ -14,6 +14,8 @@ It provides first level validation.
 2. Using:
     - [x] Select (with DISTINCT and TOP)
     - [x] Update (with typed values)
+    - [x] Insert (multi-row VALUES)
+    - [x] Delete (with joins; refused without a WHERE unless asked)
     - [x] From
     - [x] InnerJoin, LeftJoin, RightJoin, FullJoin (on two fields or on any condition), CrossJoin
     - [x] Where (with conditions)
@@ -26,7 +28,6 @@ It provides first level validation.
 
 ## Not implemented (yet)
 In planned order:
-- [ ] Insert and Delete
 - [ ] Functions (aggregates and others), GROUP BY, HAVING, CASE
 - [ ] Compound queries (UNION, INTERSECT, EXCEPT) and sub-queries
 
@@ -113,6 +114,23 @@ print(params)
 # > (20000, 'A1C%')
 # With pyodbc: cursor.execute(sql, params). For pymssql, build_with_params("format") writes %s instead.
 ```
+6. Insert and delete rows:
+```
+# Inserts rows: one tuple per row, with the values in column order
+insert = Insert(customers_table.fields.customerId, customers_table.fields.mainPhone).values(
+    ("A1C42", "555-0100"), ("B7", None)
+)
+print(QueryBuilder(insert).build())
+# > INSERT INTO Customers (customerId, mainPhone)
+# > VALUES ('A1C42', '555-0100'), ('B7', NULL)
+
+# Deletes the accounts of customer B7; a DELETE needs a WHERE, unless built with where_required=False
+delete = QueryBuilder(Delete(accounts_table), From(accounts_table), Where(accounts_table.fields.customerId.eq("B7")))
+print(delete.build())
+# > DELETE acc
+# > FROM Accounts acc
+# > WHERE acc.customerId = 'B7'
+```
 
 (Find it directly in the module example.py)
 
@@ -123,6 +141,19 @@ Python 3.10 and above.
 (None)
 
 ## Changelog
+### 0.4.0
+Queries built with 0.3.0 produce the same SQL.
+- `Insert(*columns).values(*rows)` renders `INSERT INTO Customers (id, name)` and
+  `VALUES (1, 'Ann'), (2, 'O''Brien')`. The columns are fields of one table, or a whole table. Each row is a
+  tuple of values in column order, with at most 1000 rows per INSERT, as in T-SQL. Values are escaped as in
+  conditions, plain strings included, and `Raw("DEFAULT")` writes SQL. An Insert stands alone in its query.
+- `Delete(table)` renders `DELETE` and the table's alias, or its name, and works with `From`, joins and
+  `Where`: `DELETE acc FROM Accounts acc INNER JOIN ...`. A query with a DELETE but no WHERE raises
+  `IncompatibleClausesException`, unless written `Delete(table, where_required=False)`; so does a DELETE with
+  ORDER BY.
+- Both work with `build_with_params()`. SQL Server accepts about 2,100 parameters per query, so split big
+  parameterized inserts.
+
 ### 0.3.0
 Queries built with 0.2.0 produce the same SQL, except for the fixed `Update` values below.
 - Conditions are methods of fields, functions on fields and strings: `eq`, `ne`, `lt`, `le`, `gt`, `ge`,

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sql_querystring_builder"
-version = "0.3.0"
+version = "0.4.0"
 authors = [
   { name="Wael GRIBAA", email="g.wael@outlook.fr" },
 ]

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/src/sql_querystring_builder/__init__.py

@@ -1,9 +1,11 @@
 from .clauses import (
     CrossJoin,
+    Delete,
     From,
     FullJoin,
     IncorrectUpdateException,
     InnerJoin,
+    Insert,
     LeftJoin,
     OrderBy,
     RightJoin,

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/src/sql_querystring_builder/clauses.py

@@ -1,18 +1,23 @@
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 
 from .abstract_clause import Clause
-from .conditions import Condition, Junction, check_operand, render_operand
+from .conditions import Comparable, Condition, Junction, check_operand, render_operand
 from .exceptions import SqlQueryBuilderError
 from .tables import Aliasable, Field, Fields, Table, TempTable
+from .values import render_value
 
 
 class IncorrectUpdateException(SqlQueryBuilderError):
     pass
 
 
-# TODO  Add INSERT
+def _insert_value(value: object) -> object:
+    # VALUES cannot read columns: unlike in a condition, a field or expression is no value here.
+    if isinstance(value, Comparable):
+        raise TypeError(f"Unsupported value type: {type(value).__name__}.")
+    return check_operand(value)
 
 
 def _row_count(keyword: str, value: int, minimum: int) -> int:
@@ -228,6 +233,93 @@ class Update(Clause):
         return f"{self.__class__.__name__}(updates={self.updates})"
 
 
+class Insert(Clause):
+    """`INSERT INTO table (columns)` and `VALUES (…), (…)`, with the rows added by `values()`.
+
+    The columns are fields of one table, or whole tables, as `Select` takes them. Unlike in `Update`, a plain
+    str is a value here. An Insert stands alone in its query (see `QueryBuilder.build()`).
+    """
+
+    def __init__(self, *columns: Field | Table) -> None:
+        tables: list[Table] = []
+        self.columns: list[Field] = []
+        for column in columns:
+            if isinstance(column, Table):
+                tables.append(column)
+                self.columns.extend(column.fields.as_list())
+            elif isinstance(column, Field):
+                tables.append(column.table)
+                self.columns.append(column)
+            else:
+                raise TypeError(f"Insert takes fields or tables, got {type(column).__name__}.")
+        if not self.columns:
+            raise ValueError("Insert needs at least one column.")
+        for table in tables[1:]:
+            if table.name != tables[0].name:
+                raise ValueError(f"Insert columns must come from one table, got '{tables[0].name}' and '{table.name}'.")
+        names: set[str] = set()
+        for column in self.columns:
+            if column.name in names:
+                raise ValueError(f"Insert column '{column.name}' appears twice.")
+            names.add(column.name)
+        self.table: Table = tables[0]
+        self.rows: list[tuple[object, ...]] = []
+
+    @property
+    def place(self) -> int:
+        return 0
+
+    def values(self, *rows: Sequence[object]) -> Insert:
+        """Adds rows, each a tuple or list of values in column order, and returns the Insert."""
+        if len(self.rows) + len(rows) > 1000:
+            raise ValueError(f"An INSERT takes at most 1000 rows, got {len(self.rows) + len(rows)}.")
+        checked: list[tuple[object, ...]] = []
+        expected: str = f"{len(self.columns)} value{'s' if len(self.columns) > 1 else ''}"
+        for number, row in enumerate(rows, start=len(self.rows) + 1):
+            if isinstance(row, (str, bytes)) or not isinstance(row, Sequence):
+                raise TypeError(f"An Insert row must be a tuple or list of values, got {type(row).__name__}.")
+            if len(row) != len(self.columns):
+                raise ValueError(f"Insert row {number} needs {expected}, got {len(row)}.")
+            checked.append(tuple(_insert_value(value) for value in row))
+        self.rows.extend(checked)
+        return self
+
+    def build(self) -> str:
+        if not self.rows:
+            raise ValueError("The Insert has no rows: add them with values().")
+        # T-SQL refuses an alias after INSERT INTO, and qualified column names.
+        columns: str = ", ".join(column.name for column in self.columns)
+        rows: str = ", ".join(f"({', '.join(render_value(value) for value in row)})" for row in self.rows)
+        return f"INSERT INTO {self.table.name} ({columns})\nVALUES {rows}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(columns={self.columns}, rows={len(self.rows)})"
+
+
+class Delete(Clause):
+    """`DELETE` and the table's alias, or its name; T-SQL reads an alias from `From(table)`, as for `Update`.
+
+    A query with a Delete needs a Where unless `where_required=False`: an empty filter would delete every row.
+    """
+
+    def __init__(self, table: Table, *, where_required: bool = True) -> None:
+        if not isinstance(table, Table):
+            raise TypeError(f"Delete takes a Table, got {type(table).__name__}.")
+        self.table: Table = table
+        self.where_required: bool = where_required
+
+    @property
+    def place(self) -> int:
+        return 0
+
+    def build(self) -> str:
+        return f"DELETE {self.table.build(use_name=False, use_alias=True)}"
+
+    def __repr__(self) -> str:
+        option: str = "" if self.where_required else ", where_required=False"
+        return f"{self.__class__.__name__}(table={self.table}{option})"
+
+
 class OrderBy(Clause):
     def __init__(self, field: Aliasable, descending: bool = False) -> None:
         self.ordering: list[tuple[Aliasable, bool]] = [(field, descending)]

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/src/sql_querystring_builder/query_builder.py

@@ -4,7 +4,7 @@ from collections.abc import Iterable
 from typing import Literal
 
 from .abstract_clause import Clause
-from .clauses import OrderBy, Select
+from .clauses import Delete, Insert, OrderBy, Select, Where
 from .exceptions import SqlQueryBuilderError
 from .values import parameterize
 
@@ -17,6 +17,14 @@ class IncompatibleClausesException(SqlQueryBuilderError):
     pass
 
 
+def _describe(clause: Clause) -> str:
+    """A clause's SQL for an error message, or its repr while it cannot be built (an Insert without rows)."""
+    try:
+        return clause.build()
+    except ValueError:
+        return repr(clause)
+
+
 class QueryBuilder:
     def __init__(self, *initial_clauses: Clause) -> None:
         self.places: dict[int, list[Clause]] = {}
@@ -27,7 +35,7 @@ class QueryBuilder:
         old_clause: Clause | None = self._place_is_unavailable(clause)
         if old_clause is not None:
             raise UnavailablePlaceException(
-                f"Cannot add a new clause with the same exclusive place in the query. New clause='{clause.build()}'. Old clause='{old_clause.build()}'"
+                f"Cannot add a new clause with the same exclusive place in the query. New clause='{_describe(clause)}'. Old clause='{_describe(old_clause)}'"
             )
         self.places[clause.place] = self.places.get(clause.place, []) + [clause]
         return self
@@ -39,12 +47,26 @@ class QueryBuilder:
 
     def build(self) -> str:
         clauses: list[Clause] = self._sorted_clauses()
-        # Checked at build time: TOP and paging can both be set after the clauses were added.
+        self._check_combination(clauses)
+        return "\n".join(clause.build() for clause in clauses)
+
+    @staticmethod
+    def _check_combination(clauses: list[Clause]) -> None:
+        """Rules across clauses, checked at build time: clauses stay mutable after being added."""
         has_top: bool = any(isinstance(clause, Select) and clause.top is not None for clause in clauses)
         has_paging: bool = any(isinstance(clause, OrderBy) and clause.has_paging for clause in clauses)
         if has_top and has_paging:
             raise IncompatibleClausesException("TOP cannot be combined with OFFSET/FETCH in the same query.")
-        return "\n".join(clause.build() for clause in clauses)
+        if len(clauses) > 1 and any(isinstance(clause, Insert) for clause in clauses):
+            raise IncompatibleClausesException("INSERT cannot be combined with other clauses in the same query.")
+        deletes: list[Delete] = [clause for clause in clauses if isinstance(clause, Delete)]
+        if deletes:
+            if any(isinstance(clause, OrderBy) for clause in clauses):
+                raise IncompatibleClausesException("ORDER BY cannot be combined with DELETE in the same query.")
+            if deletes[0].where_required and not any(isinstance(clause, Where) for clause in clauses):
+                raise IncompatibleClausesException(
+                    "A DELETE needs a WHERE, unless built with Delete(table, where_required=False)."
+                )
 
     def build_with_params(self, style: Literal["qmark", "format"] = "qmark") -> tuple[str, tuple[object, ...]]:
         """Builds the query with a placeholder for each value, and returns it with the values, in order.

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0/src/sql_querystring_builder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_querystring_builder
-Version: 0.3.0
+Version: 0.4.0
 Summary: Wraps string building of MS SQL queries
 Author-email: Wael GRIBAA <g.wael@outlook.fr>
 License-Expression: GPL-3.0-only
@@ -35,6 +35,8 @@ It provides first level validation.
 2. Using:
     - [x] Select (with DISTINCT and TOP)
     - [x] Update (with typed values)
+    - [x] Insert (multi-row VALUES)
+    - [x] Delete (with joins; refused without a WHERE unless asked)
     - [x] From
     - [x] InnerJoin, LeftJoin, RightJoin, FullJoin (on two fields or on any condition), CrossJoin
     - [x] Where (with conditions)
@@ -47,7 +49,6 @@ It provides first level validation.
 
 ## Not implemented (yet)
 In planned order:
-- [ ] Insert and Delete
 - [ ] Functions (aggregates and others), GROUP BY, HAVING, CASE
 - [ ] Compound queries (UNION, INTERSECT, EXCEPT) and sub-queries
 
@@ -134,6 +135,23 @@ print(params)
 # > (20000, 'A1C%')
 # With pyodbc: cursor.execute(sql, params). For pymssql, build_with_params("format") writes %s instead.
 ```
+6. Insert and delete rows:
+```
+# Inserts rows: one tuple per row, with the values in column order
+insert = Insert(customers_table.fields.customerId, customers_table.fields.mainPhone).values(
+    ("A1C42", "555-0100"), ("B7", None)
+)
+print(QueryBuilder(insert).build())
+# > INSERT INTO Customers (customerId, mainPhone)
+# > VALUES ('A1C42', '555-0100'), ('B7', NULL)
+
+# Deletes the accounts of customer B7; a DELETE needs a WHERE, unless built with where_required=False
+delete = QueryBuilder(Delete(accounts_table), From(accounts_table), Where(accounts_table.fields.customerId.eq("B7")))
+print(delete.build())
+# > DELETE acc
+# > FROM Accounts acc
+# > WHERE acc.customerId = 'B7'
+```
 
 (Find it directly in the module example.py)
 
@@ -144,6 +162,19 @@ Python 3.10 and above.
 (None)
 
 ## Changelog
+### 0.4.0
+Queries built with 0.3.0 produce the same SQL.
+- `Insert(*columns).values(*rows)` renders `INSERT INTO Customers (id, name)` and
+  `VALUES (1, 'Ann'), (2, 'O''Brien')`. The columns are fields of one table, or a whole table. Each row is a
+  tuple of values in column order, with at most 1000 rows per INSERT, as in T-SQL. Values are escaped as in
+  conditions, plain strings included, and `Raw("DEFAULT")` writes SQL. An Insert stands alone in its query.
+- `Delete(table)` renders `DELETE` and the table's alias, or its name, and works with `From`, joins and
+  `Where`: `DELETE acc FROM Accounts acc INNER JOIN ...`. A query with a DELETE but no WHERE raises
+  `IncompatibleClausesException`, unless written `Delete(table, where_required=False)`; so does a DELETE with
+  ORDER BY.
+- Both work with `build_with_params()`. SQL Server accepts about 2,100 parameters per query, so split big
+  parameterized inserts.
+
 ### 0.3.0
 Queries built with 0.2.0 produce the same SQL, except for the fixed `Update` values below.
 - Conditions are methods of fields, functions on fields and strings: `eq`, `ne`, `lt`, `le`, `gt`, `ge`,

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/src/sql_querystring_builder.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/sql_querystring_builder.egg-info/top_level.txt
 tests/test_characterization.py
 tests/test_clauses.py
 tests/test_conditions.py
+tests/test_insert_delete.py
 tests/test_queries.py
 tests/test_readme.py
 tests/test_sql_syntax.py

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/tests/test_characterization.py

@@ -32,11 +32,13 @@ class TestPublicApi(TestCase):
             "AliasableString",
             "Condition",
             "CrossJoin",
+            "Delete",
             "Field",
             "From",
             "FullJoin",
             "FunctionOnField",
             "InnerJoin",
+            "Insert",
             "LeftJoin",
             "NStr",
             "OrderBy",

sql_querystring_builder-0.4.0/tests/test_insert_delete.py

@@ -0,0 +1,227 @@
+from collections.abc import Callable
+from datetime import date
+from unittest import TestCase
+
+from sql_querystring_builder.clauses import Delete, From, InnerJoin, Insert, OrderBy, Select, Update, Where
+from sql_querystring_builder.conditions import Condition
+from sql_querystring_builder.query_builder import (
+    IncompatibleClausesException,
+    QueryBuilder,
+    UnavailablePlaceException,
+)
+from sql_querystring_builder.tables import Table, TempTable
+from sql_querystring_builder.values import NStr, Raw, Str
+
+
+class TestInsert(TestCase):
+    def setUp(self) -> None:
+        self.maxDiff = None
+        self.customers: Table = Table("Customers", "c", field_names=["id", "name", "phone"])
+
+    def test_rows(self):
+        c = self.customers.fields
+        insert = Insert(c.id, c.name).values((1, "Ann"), [2, "O'Brien"]).values((3, None))
+        expected_result: str = "INSERT INTO Customers (id, name)\nVALUES (1, 'Ann'), (2, 'O''Brien'), (3, NULL)"
+        self.assertEqual(insert.build(), expected_result)
+
+    def test_whole_table_without_aliases(self):
+        # T-SQL refuses an alias after INSERT INTO, and qualified column names: neither is written.
+        self.customers.fields.name.set_alias("customerName")
+        actual_result: str = Insert(self.customers).values((1, "Ann", "555-0100")).build()
+        self.assertEqual(actual_result, "INSERT INTO Customers (id, name, phone)\nVALUES (1, 'Ann', '555-0100')")
+
+    def test_temporary_and_bracketed_tables(self):
+        temp_table = TempTable("t", "a")
+        bracketed = Table("dbo.[My Table]", field_names=["x"])
+        self.assertEqual(Insert(temp_table).values((1,)).build(), "INSERT INTO #t (a)\nVALUES (1)")
+        self.assertEqual(Insert(bracketed).values((1,)).build(), "INSERT INTO dbo.[My Table] (x)\nVALUES (1)")
+
+    def test_values(self):
+        c = self.customers.fields
+        insert = Insert(c.id, c.name, c.phone).values(
+            (Raw("DEFAULT"), NStr("Zoé"), date(2026, 10, 11)), (True, "", 1.5)
+        )
+        expected_result: str = (
+            "INSERT INTO Customers (id, name, phone)\nVALUES (DEFAULT, N'Zoé', '20261011'), (1, '', 1.5)"
+        )
+        self.assertEqual(insert.build(), expected_result)
+
+    def test_columns(self):
+        c = self.customers.fields
+        accounts = Table("Accounts", field_names=["id"])
+        expected_err_msgs: dict[str, tuple[type, Callable[[], Insert]]] = {
+            "Insert needs at least one column.": (ValueError, lambda: Insert()),
+            "Insert takes fields or tables, got str.": (TypeError, lambda: Insert("id")),
+            "Insert columns must come from one table, got 'Customers' and 'Accounts'.": (
+                ValueError,
+                lambda: Insert(c.id, accounts.fields.id),
+            ),
+            "Insert column 'id' appears twice.": (ValueError, lambda: Insert(c.id, self.customers)),
+        }
+        for expected_err_msg, (error, make_insert) in expected_err_msgs.items():
+            with self.subTest(expected_err_msg=expected_err_msg):
+                with self.assertRaises(error) as exc:
+                    make_insert()
+                self.assertEqual(str(exc.exception), expected_err_msg)
+        with self.assertRaises(ValueError) as exc:
+            Insert(Table("Empty"))
+        self.assertEqual(str(exc.exception), "Insert needs at least one column.")
+
+    def test_rows_are_checked_when_added(self):
+        c = self.customers.fields
+        insert = Insert(c.id, c.name).values((1, "Ann"))
+        expected_err_msgs: dict[str, tuple[type, tuple[object, ...]]] = {
+            "Insert row 2 needs 2 values, got 1.": (ValueError, ((2,),)),
+            "Insert row 3 needs 2 values, got 3.": (ValueError, ((2, "Bob"), (3, "Cy", "x"))),
+            "An Insert row must be a tuple or list of values, got str.": (TypeError, ("ab",)),
+            "An Insert row must be a tuple or list of values, got dict.": (TypeError, ({c.id: 1, c.name: "x"},)),
+            "Unsupported value type: list.": (TypeError, ((2, ["Bob"]),)),
+            "Unsupported value type: Field.": (TypeError, ((2, c.phone),)),  # VALUES cannot read columns
+            "Unsupported value type: Condition.": (TypeError, ((2, c.id.eq(1)),)),
+            "nan is not a valid T-SQL number.": (ValueError, ((float("nan"), "Bob"),)),
+        }
+        for expected_err_msg, (error, rows) in expected_err_msgs.items():
+            with self.subTest(expected_err_msg=expected_err_msg):
+                with self.assertRaises(error) as exc:
+                    insert.values(*rows)
+                self.assertEqual(str(exc.exception), expected_err_msg)
+        self.assertEqual(len(insert.rows), 1)  # a refused call adds none of its rows
+        one_column = Insert(c.id)
+        with self.assertRaises(ValueError) as exc:
+            one_column.values((1, 2))
+        self.assertEqual(str(exc.exception), "Insert row 1 needs 1 value, got 2.")
+
+    def test_at_most_1000_rows(self):
+        insert = Insert(self.customers.fields.id).values(*[(n,) for n in range(999)])
+        with self.assertRaises(ValueError) as exc:
+            insert.values((999,), (1000,))  # the first row would fit, but a call adds its rows all or none
+        self.assertEqual(str(exc.exception), "An INSERT takes at most 1000 rows, got 1001.")
+        self.assertEqual(len(insert.rows), 999)
+        insert.values((999,))
+        with self.assertRaises(ValueError) as exc:
+            insert.values((1000,))
+        self.assertEqual(str(exc.exception), "An INSERT takes at most 1000 rows, got 1001.")
+        self.assertEqual(len(insert.rows), 1000)
+
+    def test_no_rows(self):
+        with self.assertRaises(ValueError) as exc:
+            Insert(self.customers).build()
+        self.assertEqual(str(exc.exception), "The Insert has no rows: add them with values().")
+
+    def test_repr(self):
+        insert = Insert(self.customers.fields.id).values((1,), (2,))
+        self.assertEqual(repr(insert), "Insert(columns=[Field(name='id', alias='None', table='Customers')], rows=2)")
+
+
+class TestInsertQueries(TestCase):
+    def setUp(self) -> None:
+        self.customers: Table = Table("Customers", "c", field_names=["id", "name"])
+        c = self.customers.fields
+        self.insert: Insert = Insert(c.id, c.name).values((1, "O'Brien"), (2, None), (Raw("DEFAULT"), "Bob"))
+
+    def test_insert_alone(self):
+        expected_result: str = "INSERT INTO Customers (id, name)\nVALUES (1, 'O''Brien'), (2, NULL), (DEFAULT, 'Bob')"
+        self.assertEqual(QueryBuilder(self.insert).build(), expected_result)
+
+    def test_parameters(self):
+        expected_result: tuple[str, tuple[object, ...]] = (
+            "INSERT INTO Customers (id, name)\nVALUES (?, ?), (?, NULL), (DEFAULT, ?)",
+            (1, "O'Brien", 2, "Bob"),
+        )
+        self.assertEqual(QueryBuilder(self.insert).build_with_params(), expected_result)
+
+    def test_insert_stands_alone(self):
+        query_builder = QueryBuilder(self.insert, Where(self.customers.fields.id.eq(1)))
+        with self.assertRaises(IncompatibleClausesException) as exc:
+            query_builder.build()
+        self.assertEqual(str(exc.exception), "INSERT cannot be combined with other clauses in the same query.")
+        with self.assertRaises(UnavailablePlaceException):
+            QueryBuilder(self.insert, Select(self.customers))
+
+    def test_clash_with_an_insert_without_rows(self):
+        # An Insert without rows cannot be built, so the message shows its repr instead of hiding the clash.
+        with self.assertRaises(UnavailablePlaceException) as exc:
+            QueryBuilder(Select(self.customers.fields.name), Insert(self.customers.fields.id))
+        self.assertEqual(
+            str(exc.exception),
+            "Cannot add a new clause with the same exclusive place in the query. "
+            "New clause='Insert(columns=[Field(name='id', alias='None', table='Customers')], rows=0)'. "
+            "Old clause='SELECT c.name'",
+        )
+
+
+class TestDelete(TestCase):
+    def setUp(self) -> None:
+        self.maxDiff = None
+        self.customers: Table = Table("Customers", "c", field_names=["id", "name"])
+        self.accounts: Table = Table("Accounts", "acc", field_names=["id", "customerId", "closed"])
+        self.logs: Table = Table("Logs", field_names=["id", "level"])
+
+    def test_delete_with_a_join(self):
+        accounts, customers = self.accounts, self.customers
+        query_builder = QueryBuilder(
+            Delete(accounts),
+            From(accounts),
+            InnerJoin(customers, on=customers.fields.id.eq(accounts.fields.customerId)),
+            Where(customers.fields.name.eq("O'Brien") & accounts.fields.closed.eq(True)),
+        )
+        expected_result: str = """DELETE acc
+FROM Accounts acc
+INNER JOIN Customers c on c.id = acc.customerId
+WHERE c.name = 'O''Brien' AND acc.closed = 1"""
+        self.assertEqual(query_builder.build(), expected_result)
+
+    def test_delete_without_alias(self):
+        query_builder = QueryBuilder(Delete(self.logs), Where(self.logs.fields.id.eq(1)))
+        self.assertEqual(query_builder.build(), "DELETE Logs\nWHERE Logs.id = 1")
+
+    def test_parameters(self):
+        query_builder = QueryBuilder(Delete(self.logs), Where(self.logs.fields.level.in_(["debug", "trace"])))
+        expected_result: tuple[str, tuple[object, ...]] = (
+            "DELETE Logs\nWHERE Logs.level IN (?, ?)",
+            ("debug", "trace"),
+        )
+        self.assertEqual(query_builder.build_with_params(), expected_result)
+
+    def test_a_where_is_required(self):
+        expected_err_msg: str = "A DELETE needs a WHERE, unless built with Delete(table, where_required=False)."
+        on: Condition = self.customers.fields.id.eq(self.accounts.fields.customerId)
+        query_builders: dict[str, QueryBuilder] = {
+            "alone": QueryBuilder(Delete(self.logs)),
+            "a join is no WHERE": QueryBuilder(
+                Delete(self.accounts), From(self.accounts), InnerJoin(self.customers, on=on)
+            ),
+        }
+        for name, query_builder in query_builders.items():
+            with self.subTest(name=name):
+                with self.assertRaises(IncompatibleClausesException) as exc:
+                    query_builder.build()
+                self.assertEqual(str(exc.exception), expected_err_msg)
+        self.assertEqual(QueryBuilder(Delete(self.logs, where_required=False)).build(), "DELETE Logs")
+
+    def test_the_where_is_checked_when_building(self):
+        query_builder = QueryBuilder(Delete(self.logs))
+        query_builder.add(Where(self.logs.fields.level.eq("debug")))
+        self.assertEqual(query_builder.build(), "DELETE Logs\nWHERE Logs.level = 'debug'")
+
+    def test_order_by_is_refused(self):
+        logs = self.logs.fields
+        query_builder = QueryBuilder(Delete(self.logs), Where(logs.id.gt(1)), OrderBy(logs.id))
+        with self.assertRaises(IncompatibleClausesException) as exc:
+            query_builder.build()
+        self.assertEqual(str(exc.exception), "ORDER BY cannot be combined with DELETE in the same query.")
+
+    def test_one_statement_per_query(self):
+        logs = self.logs.fields
+        for other in (Select(self.logs), Update({logs.level: Str("x")}), Insert(self.logs).values((1, "x"))):
+            with self.subTest(other=type(other).__name__), self.assertRaises(UnavailablePlaceException):
+                QueryBuilder(Delete(self.logs), other)
+
+    def test_delete_takes_a_table(self):
+        with self.assertRaises(TypeError) as exc:
+            Delete("Logs")
+        self.assertEqual(str(exc.exception), "Delete takes a Table, got str.")
+
+    def test_repr(self):
+        self.assertTrue(repr(Delete(self.logs)).startswith("Delete(table=Table(name='Logs'"))
+        self.assertTrue(repr(Delete(self.logs, where_required=False)).endswith(")), where_required=False)"))

{sql_querystring_builder-0.3.0 → sql_querystring_builder-0.4.0}/tests/test_sql_syntax.py

@@ -15,10 +15,12 @@ from sqlglot.errors import SqlglotError
 from sql_querystring_builder import (
     AliasableString,
     CrossJoin,
+    Delete,
     From,
     FullJoin,
     FunctionOnField,
     InnerJoin,
+    Insert,
     LeftJoin,
     NStr,
     OrderBy,
@@ -134,15 +136,34 @@ class TestSqlSyntax(TestCase):
                 From(accounts),
                 Where(accounts.fields.id.eq(1)),
             ).build_with_params()[0],
+            # Accounts has an alias, which must not reach the INSERT.
+            "insert": QueryBuilder(
+                Insert(accounts.fields.id, accounts.fields.customerId).values(
+                    (1, "O'Brien"), (Raw("DEFAULT"), NStr("é")), (3, None)
+                )
+            ).build(),
+            "parameterized insert": QueryBuilder(Insert(accounts).values((1, "x", 2, b"\x01"))).build_with_params()[0],
+            "delete with a join": QueryBuilder(
+                Delete(accounts),
+                From(accounts),
+                InnerJoin(customers, on=customers.fields.id.eq(accounts.fields.customerId)),
+                Where(customers.fields.mainPhone.like("555%") & accounts.fields.card.eq(None)),
+            ).build(),
+            "delete without alias": QueryBuilder(Delete(customers), Where(customers.fields.id.eq(1))).build(),
+            "parameterized delete": QueryBuilder(
+                Delete(customers), Where(customers.fields.id.in_([1, 2]))
+            ).build_with_params()[0],
         }
 
     def test_known_bad_output_is_rejected(self):
-        # Outputs the library produced before 0.1.0, and an unescaped quote: if these parsed, the test below
-        # would prove nothing.
+        # Outputs the library produced before 0.1.0, an unescaped quote, and the two INSERT forms T-SQL refuses
+        # (an alias after INSERT INTO, a qualified column): if these parsed, the test below would prove nothing.
         for sql in (
             "UPDATE acc\nSET acc.a AS A=1, acc.b=2",
             "SELECT #tt.id, #tt.sum of card\nFROM #tt",
             "SELECT c.id\nFROM Customers c\nWHERE c.name = 'O'Brien'",
+            "INSERT INTO Accounts acc (id)\nVALUES (1)",
+            "INSERT INTO Accounts (acc.id)\nVALUES (1)",
         ):
             with self.subTest(sql=sql), self.assertRaises(SqlglotError):
                 sqlglot.parse_one(sql, read="tsql")