sql_querystring_builder 0.1.1__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_querystring_builder
-Version: 0.1.1
+Version: 0.3.0
 Summary: Wraps string building of MS SQL queries
 Author-email: Wael GRIBAA <g.wael@outlook.fr>
 License-Expression: GPL-3.0-only
@@ -30,25 +30,26 @@ It provides first level validation.
     - [x] Field
     - [x] Function on field
     - [x] String
+    - [x] Conditions: eq, ne, lt, le, gt, ge, like, in_, between, is_null, is_not_null, combined with & | ~
+    - [x] Values: text, numbers, booleans, None, dates and times, bytes, UUIDs, and Raw SQL
 2. Using:
-    - [x] Select
-    - [x] Update
+    - [x] Select (with DISTINCT and TOP)
+    - [x] Update (with typed values)
     - [x] From
-    - [x] InnerJoin
-    - [x] Where
-    - [x] OrderBy
+    - [x] InnerJoin, LeftJoin, RightJoin, FullJoin (on two fields or on any condition), CrossJoin
+    - [x] Where (with conditions)
+    - [x] OrderBy (with OFFSET/FETCH paging)
 3. Handling automatically:
     - [x] Table aliases
     - [x] Field aliases
+    - [x] Escaped values: 'O''Brien', N'café'
+    - [x] Parameterized queries: build_with_params() writes ? (pyodbc) or %s (pymssql) and returns the values
 
 ## Not implemented (yet)
 In planned order:
-- [ ] LEFT, RIGHT, FULL and CROSS joins; SELECT DISTINCT and TOP; paging (OFFSET/FETCH)
-- [ ] Proper conditions: typed values, AND/OR/NOT, IN, BETWEEN, LIKE, IS NULL
 - [ ] Insert and Delete
 - [ ] Functions (aggregates and others), GROUP BY, HAVING, CASE
 - [ ] Compound queries (UNION, INTERSECT, EXCEPT) and sub-queries
-- [ ] Parameterized queries
 
 ## What it does not do
     Connect to a database server and run the queries by itself.
@@ -73,8 +74,8 @@ atemptable = select.to_temptable("a_temp_table")
 innerjoin = InnerJoin(accounts_table, accounts_table.fields.customerId, customers_table)
 # Defines an Order By a defined field
 orderby = OrderBy(customers_table.fields.customerId, descending=True)
-# Adds a Where filter
-where = Where(accounts_table.fields.accountId, "gt 20000 AND", customers_table.fields.customerId, "LIKE 'A1C%'")
+# Adds a Where filter: conditions are methods of fields, combined with & (and_), | (or_) and ~ (not_)
+where = Where(accounts_table.fields.accountId.gt(20000) & customers_table.fields.customerId.like("A1C%"))
 ```
 2. Inspect what those elements are made of:
 ```
@@ -97,7 +98,7 @@ print(query_str)
 # > INTO #a_temp_table
 # > FROM Customers
 # > INNER JOIN Accounts acc on acc.customerId = Customers.customerId
-# > WHERE acc.accountId gt 20000 AND Customers.customerId LIKE 'A1C%'
+# > WHERE acc.accountId > 20000 AND Customers.customerId LIKE 'A1C%'
 # > ORDER BY cid DESC
 ```
 4. Manipulate temporary tables whose components are inferred:
@@ -118,6 +119,21 @@ print(QueryBuilder(
 # > SELECT #a_temp_table.id, #a_temp_table.cid, #a_temp_table.mainPhone, #a_temp_table.accountId
 # > FROM #a_temp_table
 ```
+5. Send the values as parameters, so that they never enter the SQL text:
+```
+# Builds the same query with a placeholder for each value, and returns the values in order
+sql, params = query_builder.build_with_params()
+print(sql)
+# > SELECT Customers.id, Customers.customerId AS cid, Customers.mainPhone, acc.accountId
+# > INTO #a_temp_table
+# > FROM Customers
+# > INNER JOIN Accounts acc on acc.customerId = Customers.customerId
+# > WHERE acc.accountId > ? AND Customers.customerId LIKE ?
+# > ORDER BY cid DESC
+print(params)
+# > (20000, 'A1C%')
+# With pyodbc: cursor.execute(sql, params). For pymssql, build_with_params("format") writes %s instead.
+```
 
 (Find it directly in the module example.py)
 
@@ -128,6 +144,49 @@ Python 3.10 and above.
 (None)
 
 ## Changelog
+### 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`,
+  `like`, `in_`, `between`, `is_null` and `is_not_null`; `eq(None)` renders `IS NULL`. Combine them with
+  `&`, `|` and `~`, or with `and_()`, `or_()` and `not_()`; parentheses are added where T-SQL needs them.
+  Python's `and`, `or` and `not` raise `TypeError`, since `c1 and c2` would silently keep only `c2`.
+- Values are escaped: text becomes `'O''Brien'`, or `N'café'` when it is not ASCII (`NStr("...")` forces
+  `N'...'`). Numbers, `True`/`False` (1/0), `None` (`NULL`), dates (`'20261011'`), datetimes and times
+  (ISO), bytes (`0x...`) and UUIDs are supported; `Raw("GETDATE()")` is written verbatim.
+- `Where(condition)`, also next to raw strings, and `on=condition` on every join, for multi-column joins.
+- `QueryBuilder.build_with_params()` returns the SQL with `?` placeholders and the values, for
+  `cursor.execute(sql, params)` with pyodbc; `build_with_params("format")` writes `%s` for pymssql.
+- `Update` values: a plain string is still raw SQL (`{f: "'x'"}`), `Str("O'Brien")` is an escaped string,
+  and other values render as in conditions.
+- New top-level names: `Condition`, `Raw`, `Str` and `NStr`.
+
+Fixed:
+- `Update` values `None`, `True`/`False`, dates and fields rendered invalid or wrong SQL: `f=None`,
+  `f=True`, `f=2026-10-11` (a subtraction) or the field's description. They now render `NULL`, `1`/`0`,
+  `'20261011'` and the field's qualified name. A `Decimal` with an exponent is written in full (`1000`, not
+  `1E+3`, which T-SQL reads as a float).
+
+Breaking:
+- `Update` values of an unsupported type raise `TypeError` instead of being written with `str()`.
+
+### 0.2.0
+Queries built with 0.1.x produce the same SQL; see "Breaking" for the few behavior changes.
+- `LeftJoin`, `RightJoin` and `FullJoin` (same arguments as `InnerJoin`), and `CrossJoin(table)`.
+- `Select(..., distinct=True, top=10)` renders `SELECT DISTINCT TOP (10) ...`.
+- `OrderBy(...).offset(20).fetch(10)` adds `OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY`. Combining paging with
+  TOP raises `IncompatibleClausesException`.
+- Every exception derives from `SqlQueryBuilderError` and can be imported from `sql_querystring_builder`.
+- `table.fields["name"]`, `"name" in table.fields`, iteration and `len()`. `table.fields["add"]` also
+  reaches fields whose names clash with `Fields` methods.
+- Table names accept bracketed parts anywhere: `[Order]`, `dbo.[My Table]` (`]]` stands for `]`).
+- The README example uses `>` instead of `gt`, which is not a T-SQL operator.
+
+Breaking:
+- `TempTable(3)` raises `TypeError` instead of a bare `Exception` (same message).
+- Unknown keyword arguments to `Table`, such as `fields=[...]`, raise `TypeError` instead of being ignored.
+- Malformed bracketed names such as `dbo.Order]` or `dbo.[Order` are rejected.
+- An empty `table.fields` is now falsy.
+
 ### 0.1.1
 No change to the generated SQL.
 - The package ships a `py.typed` marker, so type checkers such as mypy now use its type hints.

sql_querystring_builder-0.3.0/README.md

@@ -0,0 +1,193 @@
+# SqlQueryBuilder
+Wraps string building of MS SQL queries.
+It provides first level validation.
+
+## Current features
+1. Provides a string building facility for:
+    - [x] Table
+    - [x] Temporary Table
+    - [x] Field
+    - [x] Function on field
+    - [x] String
+    - [x] Conditions: eq, ne, lt, le, gt, ge, like, in_, between, is_null, is_not_null, combined with & | ~
+    - [x] Values: text, numbers, booleans, None, dates and times, bytes, UUIDs, and Raw SQL
+2. Using:
+    - [x] Select (with DISTINCT and TOP)
+    - [x] Update (with typed values)
+    - [x] From
+    - [x] InnerJoin, LeftJoin, RightJoin, FullJoin (on two fields or on any condition), CrossJoin
+    - [x] Where (with conditions)
+    - [x] OrderBy (with OFFSET/FETCH paging)
+3. Handling automatically:
+    - [x] Table aliases
+    - [x] Field aliases
+    - [x] Escaped values: 'O''Brien', N'café'
+    - [x] Parameterized queries: build_with_params() writes ? (pyodbc) or %s (pymssql) and returns the values
+
+## 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
+
+## What it does not do
+    Connect to a database server and run the queries by itself.
+    It gives you the query as a string, it's then up to you to pass it to a SQL engine.
+
+## Example
+1. Define the elements of your query:
+```
+# Defines a Table for customers
+customers_table = Table("Customers").add("id", "customerId", "mainPhone")
+# Defines a Table for accounts
+accounts_table = Table("Accounts", "acc").add("id", "customerId", "accountId")
+# Selects the fields
+select = Select(customers_table, accounts_table.fields.accountId)
+# Sets an alias for an existing field
+customers_table.fields.customerId.set_alias("cid")
+# Specifies the table to take as a FROM
+from_ = From(customers_table)
+# Specifies a temporary table for the select
+atemptable = select.to_temptable("a_temp_table")
+# Defines the InnerJoin
+innerjoin = InnerJoin(accounts_table, accounts_table.fields.customerId, customers_table)
+# Defines an Order By a defined field
+orderby = OrderBy(customers_table.fields.customerId, descending=True)
+# Adds a Where filter: conditions are methods of fields, combined with & (and_), | (or_) and ~ (not_)
+where = Where(accounts_table.fields.accountId.gt(20000) & customers_table.fields.customerId.like("A1C%"))
+```
+2. Inspect what those elements are made of:
+```
+# See what the object Select looks like
+print(select)
+# > Select(fields=[Field(name='id', alias='None', table='Customers'),
+# ...    Field(name='customerId', alias='cid', table='Customers'),
+# ...    Field(name='mainPhone', alias='None', table='Customers'),
+# ...    Field(name='accountId', alias='None', table='Accounts')])
+
+# Initializes the QueryBuilder
+query_builder = QueryBuilder(select, where, orderby, innerjoin, from_)
+```
+3. Build your query:
+```
+# Builds the query
+query_str: str = query_builder.build()
+print(query_str)
+# > SELECT Customers.id, Customers.customerId AS cid, Customers.mainPhone, acc.accountId
+# > INTO #a_temp_table
+# > FROM Customers
+# > INNER JOIN Accounts acc on acc.customerId = Customers.customerId
+# > WHERE acc.accountId > 20000 AND Customers.customerId LIKE 'A1C%'
+# > ORDER BY cid DESC
+```
+4. Manipulate temporary tables whose components are inferred:
+```
+# Is able to infer fields from temporary tables and use it as with a regular table.
+temp_select = Select(atemptable)
+print(temp_select)
+# > Select(fields=[Field(name='id', alias='None', table='#a_temp_table'),
+# ...    Field(name='cid', alias='None', table='#a_temp_table'),
+# ...    Field(name='mainPhone', alias='None', table='#a_temp_table'),
+# ...    Field(name='accountId', alias='None', table='#a_temp_table')])
+
+# Builds the query from the temporary table
+print(QueryBuilder(
+        temp_select,
+        From(atemptable)
+    ).build())
+# > SELECT #a_temp_table.id, #a_temp_table.cid, #a_temp_table.mainPhone, #a_temp_table.accountId
+# > FROM #a_temp_table
+```
+5. Send the values as parameters, so that they never enter the SQL text:
+```
+# Builds the same query with a placeholder for each value, and returns the values in order
+sql, params = query_builder.build_with_params()
+print(sql)
+# > SELECT Customers.id, Customers.customerId AS cid, Customers.mainPhone, acc.accountId
+# > INTO #a_temp_table
+# > FROM Customers
+# > INNER JOIN Accounts acc on acc.customerId = Customers.customerId
+# > WHERE acc.accountId > ? AND Customers.customerId LIKE ?
+# > ORDER BY cid DESC
+print(params)
+# > (20000, 'A1C%')
+# With pyodbc: cursor.execute(sql, params). For pymssql, build_with_params("format") writes %s instead.
+```
+
+(Find it directly in the module example.py)
+
+## Compatible versions
+Python 3.10 and above.
+
+## Dependencies
+(None)
+
+## Changelog
+### 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`,
+  `like`, `in_`, `between`, `is_null` and `is_not_null`; `eq(None)` renders `IS NULL`. Combine them with
+  `&`, `|` and `~`, or with `and_()`, `or_()` and `not_()`; parentheses are added where T-SQL needs them.
+  Python's `and`, `or` and `not` raise `TypeError`, since `c1 and c2` would silently keep only `c2`.
+- Values are escaped: text becomes `'O''Brien'`, or `N'café'` when it is not ASCII (`NStr("...")` forces
+  `N'...'`). Numbers, `True`/`False` (1/0), `None` (`NULL`), dates (`'20261011'`), datetimes and times
+  (ISO), bytes (`0x...`) and UUIDs are supported; `Raw("GETDATE()")` is written verbatim.
+- `Where(condition)`, also next to raw strings, and `on=condition` on every join, for multi-column joins.
+- `QueryBuilder.build_with_params()` returns the SQL with `?` placeholders and the values, for
+  `cursor.execute(sql, params)` with pyodbc; `build_with_params("format")` writes `%s` for pymssql.
+- `Update` values: a plain string is still raw SQL (`{f: "'x'"}`), `Str("O'Brien")` is an escaped string,
+  and other values render as in conditions.
+- New top-level names: `Condition`, `Raw`, `Str` and `NStr`.
+
+Fixed:
+- `Update` values `None`, `True`/`False`, dates and fields rendered invalid or wrong SQL: `f=None`,
+  `f=True`, `f=2026-10-11` (a subtraction) or the field's description. They now render `NULL`, `1`/`0`,
+  `'20261011'` and the field's qualified name. A `Decimal` with an exponent is written in full (`1000`, not
+  `1E+3`, which T-SQL reads as a float).
+
+Breaking:
+- `Update` values of an unsupported type raise `TypeError` instead of being written with `str()`.
+
+### 0.2.0
+Queries built with 0.1.x produce the same SQL; see "Breaking" for the few behavior changes.
+- `LeftJoin`, `RightJoin` and `FullJoin` (same arguments as `InnerJoin`), and `CrossJoin(table)`.
+- `Select(..., distinct=True, top=10)` renders `SELECT DISTINCT TOP (10) ...`.
+- `OrderBy(...).offset(20).fetch(10)` adds `OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY`. Combining paging with
+  TOP raises `IncompatibleClausesException`.
+- Every exception derives from `SqlQueryBuilderError` and can be imported from `sql_querystring_builder`.
+- `table.fields["name"]`, `"name" in table.fields`, iteration and `len()`. `table.fields["add"]` also
+  reaches fields whose names clash with `Fields` methods.
+- Table names accept bracketed parts anywhere: `[Order]`, `dbo.[My Table]` (`]]` stands for `]`).
+- The README example uses `>` instead of `gt`, which is not a T-SQL operator.
+
+Breaking:
+- `TempTable(3)` raises `TypeError` instead of a bare `Exception` (same message).
+- Unknown keyword arguments to `Table`, such as `fields=[...]`, raise `TypeError` instead of being ignored.
+- Malformed bracketed names such as `dbo.Order]` or `dbo.[Order` are rejected.
+- An empty `table.fields` is now falsy.
+
+### 0.1.1
+No change to the generated SQL.
+- The package ships a `py.typed` marker, so type checkers such as mypy now use its type hints.
+- PyPI classifiers for the supported Python versions (3.10 to 3.14), typing and topic.
+- The "Not implemented (yet)" list shows the planned features in order; typo fixes.
+
+### 0.1.0
+This release changes the generated SQL: check your queries when upgrading.
+- WHERE conditions and the right side of `INNER JOIN ... on` use the field's qualified name (`t1.KeyId`)
+  instead of its SELECT alias, which SQL Server only accepts in ORDER BY. ORDER BY still uses the alias.
+- `UPDATE ... SET` no longer writes `AS alias` after aliased fields (`SET acc.a=1`).
+- Temporary tables made with `Select.to_temptable()` name their columns after the field aliases, as
+  `SELECT ... INTO` does.
+- Adding the same field name twice in one call (`Table("t").add("a", "a")`), including duplicate
+  temporary-table columns, raises `AlreadyExistingFieldException`.
+- An `Update` mixing two tables with the same name but different aliases raises `IncorrectUpdateException`.
+- `NonExistingFieldException` is now an `AttributeError`: `hasattr()` and `getattr(..., default)` work on
+  `table.fields`, and tables can be copied and pickled.
+- Requires Python 3.10 or later (was 3.7).
+- The license metadata uses the SPDX expression `GPL-3.0-only`.
+
+## Authors
+Wael GRIBAA
+Contact: g.wael@outlook.fr
+Made in September 2024

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sql_querystring_builder"
-version = "0.1.1"
+version = "0.3.0"
 authors = [
   { name="Wael GRIBAA", email="g.wael@outlook.fr" },
 ]
@@ -34,6 +34,7 @@ dev = [
     "mypy>=2.4.0",
     "pytest>=9.1.1",
     "ruff>=0.17.0",
+    "sqlglot==30.19.0",
 ]
 
 [tool.ruff]

sql_querystring_builder-0.3.0/src/sql_querystring_builder/__init__.py

@@ -0,0 +1,30 @@
+from .clauses import (
+    CrossJoin,
+    From,
+    FullJoin,
+    IncorrectUpdateException,
+    InnerJoin,
+    LeftJoin,
+    OrderBy,
+    RightJoin,
+    Select,
+    Update,
+    Where,
+)
+from .conditions import Condition
+from .exceptions import SqlQueryBuilderError
+from .query_builder import IncompatibleClausesException, QueryBuilder, UnavailablePlaceException
+from .tables import (
+    AliasableString,
+    AliasException,
+    AlreadyExistingFieldException,
+    Field,
+    FunctionOnField,
+    InvalidNameException,
+    NonExistingAliasException,
+    NonExistingFieldException,
+    Table,
+    TableException,
+    TempTable,
+)
+from .values import NStr, Raw, Str

sql_querystring_builder-0.3.0/src/sql_querystring_builder/clauses.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from .abstract_clause import Clause
+from .conditions import Condition, Junction, check_operand, render_operand
+from .exceptions import SqlQueryBuilderError
+from .tables import Aliasable, Field, Fields, Table, TempTable
+
+
+class IncorrectUpdateException(SqlQueryBuilderError):
+    pass
+
+
+# TODO  Add INSERT
+
+
+def _row_count(keyword: str, value: int, minimum: int) -> int:
+    """Validates a row count for TOP, OFFSET or FETCH."""
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{keyword} must be an int, got {type(value).__name__}.")
+    if value < minimum:
+        expected: str = "zero or more" if minimum == 0 else f"at least {minimum}"
+        raise ValueError(f"{keyword} must be {expected}, got {value}.")
+    return value
+
+
+class Select(Clause):
+    def __init__(self, *fields: Fields | Aliasable | Table, distinct: bool = False, top: int | None = None) -> None:
+        if top is not None:
+            _row_count("TOP", top, minimum=0)
+        self.fields: list[Aliasable] = []
+        for el in fields:
+            if isinstance(el, Fields):
+                self.fields.extend(el.as_list())
+            elif isinstance(el, Table):
+                self.fields.extend(el.fields.as_list())
+            else:
+                self.fields.append(el)
+        self.distinct: bool = distinct
+        self.top: int | None = top
+        self.temp_table: TempTable | None = None
+
+    @property
+    def place(self) -> int:
+        return 0
+
+    def build(self) -> str:
+        head: str = "SELECT"
+        if self.distinct:
+            head += " DISTINCT"
+        if self.top is not None:
+            head += f" TOP ({self.top})"
+        ret: str = f"{head} " + (", ".join([field.build(True, True) for field in self.fields]) if self.fields else "*")
+        if self.temp_table is not None:
+            ret += "\nINTO " + self.temp_table.build()
+        return ret
+
+    def to_temptable(self, name: str) -> TempTable:
+        self.temp_table = TempTable(name, *self.fields)
+        return self.temp_table
+
+    def __repr__(self) -> str:
+        options: str = (", distinct=True" if self.distinct else "") + (
+            f", top={self.top}" if self.top is not None else ""
+        )
+        return f"{self.__class__.__name__}(fields={self.fields}{options})"
+
+
+class From(Clause):
+    def __init__(self, table: Table) -> None:
+        self.table: Table = table
+
+    @property
+    def place(self) -> int:
+        return 2
+
+    def build(self) -> str:
+        return f"FROM {self.table.build(True)}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(table={self.table})"
+
+
+class Where(Clause):
+    """`WHERE` and its parts, joined by spaces: conditions, fields, and strings written as raw SQL."""
+
+    def __init__(self, *conditions: str | Aliasable | Condition) -> None:
+        self.conditions: tuple[str | Aliasable | Condition, ...] = conditions
+
+    @property
+    def place(self) -> int:
+        return 4
+
+    def build(self) -> str:
+        ret: list[str] = ["WHERE"]
+        for condition in self.conditions:
+            if isinstance(condition, Condition):
+                sql: str = condition.build()
+                # Next to raw strings, an AND or OR condition keeps its meaning only in parentheses.
+                ret.append(f"({sql})" if isinstance(condition, Junction) and len(self.conditions) > 1 else sql)
+            else:
+                ret.append(condition.build() if isinstance(condition, Aliasable) else condition)
+        return " ".join(ret)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(conditions={self.conditions})"
+
+
+class Join(Clause):
+    """A join on `on_left = on_right`, or on any condition given as `on`; each subclass only sets its `keyword`."""
+
+    keyword: str
+
+    def __init__(
+        self,
+        table: Table,
+        on_left: Field | None = None,
+        on_right: Field | Table | None = None,
+        *,
+        on: Condition | None = None,
+    ) -> None:
+        if on is None:
+            if on_left is None or on_right is None:
+                raise TypeError(f"{self.__class__.__name__} needs on_left and on_right, or on.")
+            on_right = on_right if isinstance(on_right, Aliasable) else on_right.fields[on_left.name]
+            on = on_left.eq(on_right)
+        elif on_left is not None or on_right is not None:
+            raise TypeError(f"{self.__class__.__name__} takes on_left and on_right, or on, not both.")
+        elif not isinstance(on, Condition):
+            raise TypeError(f"on must be a Condition, got {type(on).__name__}.")
+        self.table: Table = table
+        self.on_left: Field | None = on_left
+        self.on_right: Field | None = on_right
+        self.on: Condition = on
+
+    @property
+    def place(self) -> int:
+        return 3
+
+    @property
+    def is_exclusive(self) -> bool:
+        return False
+
+    def build(self) -> str:
+        return f"{self.keyword} {self.table.build(use_name=True)} on {self.on.build()}"
+
+    def __repr__(self) -> str:
+        if self.on_left is None:
+            return f"{self.__class__.__name__}(table={self.table}, on={self.on})"
+        return f"{self.__class__.__name__}(table={self.table}, on_left={self.on_left}, on_right={self.on_right})"
+
+
+class InnerJoin(Join):
+    keyword = "INNER JOIN"
+
+
+class LeftJoin(Join):
+    keyword = "LEFT JOIN"
+
+
+class RightJoin(Join):
+    keyword = "RIGHT JOIN"
+
+
+class FullJoin(Join):
+    keyword = "FULL JOIN"
+
+
+class CrossJoin(Clause):
+    def __init__(self, table: Table) -> None:
+        self.table: Table = table
+
+    @property
+    def place(self) -> int:
+        return 3
+
+    @property
+    def is_exclusive(self) -> bool:
+        return False
+
+    def build(self) -> str:
+        return f"CROSS JOIN {self.table.build(use_name=True)}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(table={self.table})"
+
+
+class Update(Clause):
+    """`UPDATE … SET field=value, …`: a plain str value is raw SQL (`"'x'"`), `Str("x")` an escaped string.
+
+    Any other value goes through `values.py`, like a value in a condition: `None` is `NULL`, a field is its
+    qualified name.
+    """
+
+    def __init__(self, updates: Mapping[Field, object]) -> None:
+        if not updates:
+            raise IncorrectUpdateException("The Update is empty.")
+        self.updates: dict[Field, object] = {}
+        first_table: Table | None = None
+        for field, value in updates.items():
+            if first_table is None:
+                first_table = field.table
+            elif (first_table.name, first_table.alias) != (field.table.name, field.table.alias):
+                # The same name under another alias is still another table in the query: show the aliases.
+                same_name: bool = first_table.name == field.table.name
+                first: str = first_table.build(use_name=True) if same_name else first_table.name
+                other: str = field.table.build(use_name=True) if same_name else field.table.name
+                raise IncorrectUpdateException(
+                    f"Two different tables cannot be updated in the same Update: '{first}' and '{other}'."
+                )
+            self.updates[field] = value if isinstance(value, str) else check_operand(value)
+        self.table: Table = field.table
+
+    @property
+    def place(self) -> int:
+        return 0
+
+    def build(self) -> str:
+        # A plain str stays raw SQL until 1.0 (D4 in ROADMAP.md): turning it into a value would quote it.
+        field_strings: list[str] = [
+            f"{field.build()}={value if isinstance(value, str) else render_operand(value)}"
+            for field, value in self.updates.items()
+        ]
+        return f"UPDATE {self.table.build(use_name=False, use_alias=True)}\nSET " + ", ".join(field_strings)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(updates={self.updates})"
+
+
+class OrderBy(Clause):
+    def __init__(self, field: Aliasable, descending: bool = False) -> None:
+        self.ordering: list[tuple[Aliasable, bool]] = [(field, descending)]
+        self.offset_rows: int | None = None
+        self.fetch_rows: int | None = None
+
+    @property
+    def place(self) -> int:
+        return 5
+
+    @property
+    def has_paging(self) -> bool:
+        return self.offset_rows is not None or self.fetch_rows is not None
+
+    def add(self, field: Aliasable, descending: bool = False) -> OrderBy:
+        self.ordering.append((field, descending))
+        return self
+
+    def offset(self, rows: int) -> OrderBy:
+        self.offset_rows = _row_count("OFFSET", rows, minimum=0)
+        return self
+
+    def fetch(self, rows: int) -> OrderBy:
+        self.fetch_rows = _row_count("FETCH", rows, minimum=1)
+        return self
+
+    def build(self) -> str:
+        ret_list: list[str] = []
+        for field, desc in self.ordering:
+            ret_list.append(f"{field.build(use_name=False, use_alias=True)}{' DESC' if desc else ''}")
+        ret: str = "ORDER BY " + ", ".join(ret_list)
+        if self.has_paging:
+            # T-SQL requires OFFSET before FETCH: fetch() alone starts at the first row.
+            ret += f"\nOFFSET {self.offset_rows or 0} ROWS"
+            if self.fetch_rows is not None:
+                ret += f" FETCH NEXT {self.fetch_rows} ROWS ONLY"
+        return ret
+
+    def __repr__(self) -> str:
+        paging: str = (f", offset={self.offset_rows}" if self.offset_rows is not None else "") + (
+            f", fetch={self.fetch_rows}" if self.fetch_rows is not None else ""
+        )
+        return f"{self.__class__.__name__}(ordering={self.ordering}{paging})"