sqlstratum 0.1.0__tar.gz

sqlstratum-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antonio Ognio <aognio@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlstratum-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: sqlstratum
+Version: 0.1.0
+Summary: Lightweight, source-first SQL AST + compiler + runner.
+Author-email: Antonio Ognio <aognio@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Antonio Ognio <aognio@gmail.com>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/aognio/sqlstratum
+Project-URL: Repository, https://github.com/aognio/sqlstratum
+Project-URL: Issues, https://github.com/aognio/sqlstratum/issues
+Keywords: sql,query-builder,sqlite,compiler,ast
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# SQLStratum
+
+<p align="center">
+  <img src="assets/images/SQLStratum-Logo-500x500-transparent.png" alt="SQLStratum logo" />
+</p>
+
+SQLStratum is a modern, typed, deterministic SQL query builder and compiler for Python with a 
+SQLite runner and a hydration pipeline. It exists to give applications and ORMs a reliable foundation 
+layer with composable SQL, predictable parameter binding, and explicit execution boundaries.
+
+## Key Features
+- Deterministic compilation: identical AST inputs produce identical SQL + params
+- Typed, composable DSL for SELECT/INSERT/UPDATE/DELETE
+- Safe parameter binding (no raw interpolation)
+- Hydration targets for structured results
+- SQLite-first execution via a small Runner API
+- Testable compiled output and runtime behavior
+
+## Non-Goals
+- Not an ORM (no identity map, relationships, lazy loading)
+- Not a migrations/DDL system
+- Not a full database abstraction layer for every backend yet (SQLite first)
+- Not a SQL string templating engine
+
+SQLStratum focuses on queries. DDL statements such as `CREATE TABLE` or `ALTER TABLE` are intended to
+live in a complementary library with similar design goals that is currently in the works.
+
+## Quickstart
+```python
+import sqlite3
+
+from sqlstratum import SELECT, INSERT, Table, col, Runner
+
+users = Table(
+    "users",
+    col("id", int),
+    col("email", str),
+    col("active", int),
+)
+
+conn = sqlite3.connect(":memory:")
+runner = Runner(conn)
+runner.exec_ddl("CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT, active INTEGER)")
+
+runner.execute(INSERT(users).VALUES(email="a@b.com", active=1))
+runner.execute(INSERT(users).VALUES(email="c@d.com", active=0))
+
+q = (
+    SELECT(users.c.id, users.c.email)
+    .FROM(users)
+    .WHERE(users.c.active.is_true())
+    .HYDRATE(dict)
+)
+
+rows = runner.fetch_all(q)
+print(rows)
+```
+
+## Why `Table` objects?
+SQLStratum’s `Table` objects are the schema anchor for the typed, deterministic query builder. They
+provides column metadata and a stable namespace for column access, which enables predictable SQL
+generation and safe parameter binding. They also support explicit aliasing to avoid ambiguous column
+names in joins.
+
+## Project Structure
+- AST: immutable query nodes in `sqlstratum/ast.py`
+- Compiler: SQL + params generation in `sqlstratum/compile.py`
+- Runner: SQLite execution and transactions in `sqlstratum/runner.py`
+- Hydration: projection rules and targets in `sqlstratum/hydrate.py`
+
+## SQL Debugging
+SQLStratum can log executed SQL statements (compiled SQL + parameters + duration), but logging is
+intentionally gated to avoid noisy output in production. Debug output requires two conditions:
+- Environment variable gate: `SQLSTRATUM_DEBUG` must be truthy (`"1"`, `"true"`, `"yes"`,
+  case-insensitive).
+- Logger gate: the `sqlstratum` logger must be DEBUG-enabled.
+
+Why it does not work by default: Python logging defaults to WARNING level, so even if
+`SQLSTRATUM_DEBUG=1` is set, DEBUG logs will not appear unless logging is configured.
+
+To enable debugging in a development app:
+
+Step 1 - set the environment variable:
+```
+SQLSTRATUM_DEBUG=1
+```
+
+Step 2 - configure logging early in the app:
+```python
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+# or
+logging.getLogger("sqlstratum").setLevel(logging.DEBUG)
+```
+
+Output looks like:
+```
+SQL: <compiled sql> | params={<sorted params>} | duration_ms=<...>
+```
+
+Architectural intent: logging happens at the Runner boundary (after execution). AST building and
+compilation remain deterministic and side-effect free, preserving separation of concerns.
+
+## Logo Inspiration
+
+Vinicunca (Rainbow Mountain) in Peru’s Cusco Region — a high-altitude day hike from
+Cusco at roughly 5,036 m (16,500 ft). See [Vinicunca](https://en.wikipedia.org/wiki/Vinicunca) for
+background.
+
+## Versioning / Roadmap
+Current version: `0.1.0`.
+Design notes and current limitations are tracked in `NOTES.md`. Roadmap planning is intentionally
+minimal at this stage and will evolve with real usage.
+
+## Authorship
+[Antonio Ognio](https://github.com/aognio/) is the maintainer and author of SQLStratum. ChatGPT is used for brainstorming,
+architectural thinking, documentation drafting, and project management advisory. Codex (CLI/agentic
+coding) is used to implement many code changes under Antonio's direction and review. The maintainer
+reviews and curates changes; AI tools are assistants, not owners, and accountability remains with the
+maintainer.
+
+## License
+MIT License.
+
+## Contributing
+PRs are welcome. Please read `CONTRIBUTING.md` for the workflow and expectations.

sqlstratum-0.1.0/README.md

@@ -0,0 +1,127 @@
+# SQLStratum
+
+<p align="center">
+  <img src="assets/images/SQLStratum-Logo-500x500-transparent.png" alt="SQLStratum logo" />
+</p>
+
+SQLStratum is a modern, typed, deterministic SQL query builder and compiler for Python with a 
+SQLite runner and a hydration pipeline. It exists to give applications and ORMs a reliable foundation 
+layer with composable SQL, predictable parameter binding, and explicit execution boundaries.
+
+## Key Features
+- Deterministic compilation: identical AST inputs produce identical SQL + params
+- Typed, composable DSL for SELECT/INSERT/UPDATE/DELETE
+- Safe parameter binding (no raw interpolation)
+- Hydration targets for structured results
+- SQLite-first execution via a small Runner API
+- Testable compiled output and runtime behavior
+
+## Non-Goals
+- Not an ORM (no identity map, relationships, lazy loading)
+- Not a migrations/DDL system
+- Not a full database abstraction layer for every backend yet (SQLite first)
+- Not a SQL string templating engine
+
+SQLStratum focuses on queries. DDL statements such as `CREATE TABLE` or `ALTER TABLE` are intended to
+live in a complementary library with similar design goals that is currently in the works.
+
+## Quickstart
+```python
+import sqlite3
+
+from sqlstratum import SELECT, INSERT, Table, col, Runner
+
+users = Table(
+    "users",
+    col("id", int),
+    col("email", str),
+    col("active", int),
+)
+
+conn = sqlite3.connect(":memory:")
+runner = Runner(conn)
+runner.exec_ddl("CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT, active INTEGER)")
+
+runner.execute(INSERT(users).VALUES(email="a@b.com", active=1))
+runner.execute(INSERT(users).VALUES(email="c@d.com", active=0))
+
+q = (
+    SELECT(users.c.id, users.c.email)
+    .FROM(users)
+    .WHERE(users.c.active.is_true())
+    .HYDRATE(dict)
+)
+
+rows = runner.fetch_all(q)
+print(rows)
+```
+
+## Why `Table` objects?
+SQLStratum’s `Table` objects are the schema anchor for the typed, deterministic query builder. They
+provides column metadata and a stable namespace for column access, which enables predictable SQL
+generation and safe parameter binding. They also support explicit aliasing to avoid ambiguous column
+names in joins.
+
+## Project Structure
+- AST: immutable query nodes in `sqlstratum/ast.py`
+- Compiler: SQL + params generation in `sqlstratum/compile.py`
+- Runner: SQLite execution and transactions in `sqlstratum/runner.py`
+- Hydration: projection rules and targets in `sqlstratum/hydrate.py`
+
+## SQL Debugging
+SQLStratum can log executed SQL statements (compiled SQL + parameters + duration), but logging is
+intentionally gated to avoid noisy output in production. Debug output requires two conditions:
+- Environment variable gate: `SQLSTRATUM_DEBUG` must be truthy (`"1"`, `"true"`, `"yes"`,
+  case-insensitive).
+- Logger gate: the `sqlstratum` logger must be DEBUG-enabled.
+
+Why it does not work by default: Python logging defaults to WARNING level, so even if
+`SQLSTRATUM_DEBUG=1` is set, DEBUG logs will not appear unless logging is configured.
+
+To enable debugging in a development app:
+
+Step 1 - set the environment variable:
+```
+SQLSTRATUM_DEBUG=1
+```
+
+Step 2 - configure logging early in the app:
+```python
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+# or
+logging.getLogger("sqlstratum").setLevel(logging.DEBUG)
+```
+
+Output looks like:
+```
+SQL: <compiled sql> | params={<sorted params>} | duration_ms=<...>
+```
+
+Architectural intent: logging happens at the Runner boundary (after execution). AST building and
+compilation remain deterministic and side-effect free, preserving separation of concerns.
+
+## Logo Inspiration
+
+Vinicunca (Rainbow Mountain) in Peru’s Cusco Region — a high-altitude day hike from
+Cusco at roughly 5,036 m (16,500 ft). See [Vinicunca](https://en.wikipedia.org/wiki/Vinicunca) for
+background.
+
+## Versioning / Roadmap
+Current version: `0.1.0`.
+Design notes and current limitations are tracked in `NOTES.md`. Roadmap planning is intentionally
+minimal at this stage and will evolve with real usage.
+
+## Authorship
+[Antonio Ognio](https://github.com/aognio/) is the maintainer and author of SQLStratum. ChatGPT is used for brainstorming,
+architectural thinking, documentation drafting, and project management advisory. Codex (CLI/agentic
+coding) is used to implement many code changes under Antonio's direction and review. The maintainer
+reviews and curates changes; AI tools are assistants, not owners, and accountability remains with the
+maintainer.
+
+## License
+MIT License.
+
+## Contributing
+PRs are welcome. Please read `CONTRIBUTING.md` for the workflow and expectations.

sqlstratum-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqlstratum"
+version = "0.1.0"
+description = "Lightweight, source-first SQL AST + compiler + runner."
+readme = { file = "README.md", content-type = "text/markdown" }
+license = { file = "LICENSE" }
+authors = [
+  { name = "Antonio Ognio", email = "aognio@gmail.com" },
+]
+keywords = ["sql", "query-builder", "sqlite", "compiler", "ast"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Database",
+  "Topic :: Software Development :: Libraries",
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/aognio/sqlstratum"
+Repository = "https://github.com/aognio/sqlstratum"
+Issues = "https://github.com/aognio/sqlstratum/issues"
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2.0",
+  "twine>=5.0.0",
+]
+
+[tool.setuptools]
+packages = ["sqlstratum"]

sqlstratum-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlstratum-0.1.0/sqlstratum/__init__.py

@@ -0,0 +1,32 @@
+"""sqlstratum: minimal SQL AST + compiler + sqlite runner."""
+from .dsl import SELECT, INSERT, UPDATE, DELETE, OR, AND, NOT
+from .expr import COUNT, SUM, AVG, MIN, MAX
+from .meta import Table, Column, col
+from .compile import compile
+from .runner import Runner
+from .types import Expression, HydrationTarget, Hydrator, Predicate, Source
+
+__all__ = [
+    "SELECT",
+    "INSERT",
+    "UPDATE",
+    "DELETE",
+    "OR",
+    "AND",
+    "NOT",
+    "COUNT",
+    "SUM",
+    "AVG",
+    "MIN",
+    "MAX",
+    "Table",
+    "Column",
+    "col",
+    "compile",
+    "Runner",
+    "Expression",
+    "HydrationTarget",
+    "Hydrator",
+    "Predicate",
+    "Source",
+]

sqlstratum-0.1.0/sqlstratum/ast.py

@@ -0,0 +1,96 @@
+"""AST node definitions for sqlstratum."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, Optional, Sequence, Tuple, TypeVar
+
+from .meta import Column
+from .expr import OrderSpec
+from .types import Expression, HydrationTarget, Predicate, Source
+
+
+@dataclass(frozen=True)
+class Compiled:
+    sql: str
+    params: Dict[str, Any]
+
+
+@dataclass(frozen=True)
+class SelectQuery:
+    projections: Tuple[Expression, ...]
+    from_: Optional[Source]
+    joins: Tuple["Join", ...]
+    where: Tuple[Predicate, ...]
+    group_by: Tuple[Expression, ...]
+    having: Tuple[Predicate, ...]
+    order_by: Tuple[OrderSpec, ...]
+    limit: Optional[int]
+    offset: Optional[int]
+    distinct: bool
+    hydrate: HydrationTarget
+
+
+@dataclass(frozen=True)
+class Join:
+    kind: str  # "INNER" or "LEFT"
+    source: Source
+    on: Predicate
+
+
+@dataclass(frozen=True)
+class InsertQuery:
+    table: Any
+    values: Tuple[Tuple[str, Any], ...]
+
+
+@dataclass(frozen=True)
+class UpdateQuery:
+    table: Any
+    values: Tuple[Tuple[str, Any], ...]
+    where: Tuple[Predicate, ...]
+
+
+@dataclass(frozen=True)
+class DeleteQuery:
+    table: Any
+    where: Tuple[Predicate, ...]
+
+
+@dataclass(frozen=True)
+class Subquery:
+    query: SelectQuery
+    alias: str
+    c: Any = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "c", _SubqueryColumnAccessor(self.alias))
+
+    def __getattr__(self, item: str) -> Column:
+        return getattr(self.c, item)
+
+
+@dataclass(frozen=True)
+class _SubqueryTable:
+    name: str
+    alias: Optional[str] = None
+
+
+class _SubqueryColumnAccessor:
+    def __init__(self, alias: str) -> None:
+        self._alias = alias
+
+    def __getattr__(self, item: str) -> Column:
+        return Column(name=item, py_type=object, table=_SubqueryTable(self._alias))
+
+
+@dataclass(frozen=True)
+class ExecutionResult:
+    rowcount: int
+    lastrowid: Optional[int]
+
+
+T = TypeVar("T")
+
+
+def tupled(items: Iterable[T]) -> Tuple[T, ...]:
+    return tuple(items)

sqlstratum-0.1.0/sqlstratum/compile.py

@@ -0,0 +1,156 @@
+"""SQLite compiler for sqlstratum AST."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List
+
+from . import ast
+from .expr import (
+    AliasExpr,
+    BinaryPredicate,
+    Function,
+    Literal,
+    LogicalPredicate,
+    NotPredicate,
+    OrderSpec,
+    UnaryPredicate,
+)
+from .meta import Column, Table
+from .types import Predicate
+
+
+@dataclass(frozen=True)
+class Compiled(ast.Compiled):
+    pass
+
+
+def compile(query: Any, dialect: str = "sqlite") -> Compiled:
+    if dialect != "sqlite":
+        raise ValueError("Only sqlite dialect is supported in v0.1")
+    compiler = _Compiler()
+    sql = compiler.compile_query(query)
+    return Compiled(sql=sql, params=compiler.params)
+
+
+class _Compiler:
+    def __init__(self) -> None:
+        self.params: Dict[str, Any] = {}
+        self._param_index = 0
+
+    def compile_query(self, query: Any) -> str:
+        if isinstance(query, ast.SelectQuery):
+            return self._compile_select(query)
+        if isinstance(query, ast.InsertQuery):
+            return self._compile_insert(query)
+        if isinstance(query, ast.UpdateQuery):
+            return self._compile_update(query)
+        if isinstance(query, ast.DeleteQuery):
+            return self._compile_delete(query)
+        raise TypeError(f"Unsupported query type: {type(query)}")
+
+    def _compile_select(self, query: ast.SelectQuery) -> str:
+        parts: List[str] = []
+        distinct = "DISTINCT " if query.distinct else ""
+        projections = ", ".join(self._compile_projection(p) for p in query.projections)
+        parts.append(f"SELECT {distinct}{projections}")
+        if query.from_ is not None:
+            parts.append("FROM " + self._compile_source(query.from_))
+        for join in query.joins:
+            join_sql = "JOIN" if join.kind == "INNER" else "LEFT JOIN"
+            parts.append(f"{join_sql} {self._compile_source(join.source)} ON {self._compile_predicate(join.on)}")
+        if query.where:
+            parts.append("WHERE " + self._compile_and_list(query.where))
+        if query.group_by:
+            parts.append("GROUP BY " + ", ".join(self._compile_expr(e) for e in query.group_by))
+        if query.having:
+            parts.append("HAVING " + self._compile_and_list(query.having))
+        if query.order_by:
+            parts.append("ORDER BY " + ", ".join(self._compile_order(o) for o in query.order_by))
+        if query.limit is not None:
+            parts.append("LIMIT " + self._bind(query.limit))
+        if query.offset is not None:
+            parts.append("OFFSET " + self._bind(query.offset))
+        return " ".join(parts)
+
+    def _compile_insert(self, query: ast.InsertQuery) -> str:
+        columns = ", ".join(self._quote(k) for k, _ in query.values)
+        values = ", ".join(self._bind(v) for _, v in query.values)
+        return f"INSERT INTO {self._compile_table(query.table)} ({columns}) VALUES ({values})"
+
+    def _compile_update(self, query: ast.UpdateQuery) -> str:
+        sets = ", ".join(f"{self._quote(k)} = {self._bind(v)}" for k, v in query.values)
+        parts = [f"UPDATE {self._compile_table(query.table)} SET {sets}"]
+        if query.where:
+            parts.append("WHERE " + self._compile_and_list(query.where))
+        return " ".join(parts)
+
+    def _compile_delete(self, query: ast.DeleteQuery) -> str:
+        parts = [f"DELETE FROM {self._compile_table(query.table)}"]
+        if query.where:
+            parts.append("WHERE " + self._compile_and_list(query.where))
+        return " ".join(parts)
+
+    def _compile_projection(self, expr: Any) -> str:
+        return self._compile_expr(expr)
+
+    def _compile_source(self, source: Any) -> str:
+        if isinstance(source, Table):
+            return self._compile_table(source)
+        if isinstance(source, ast.Subquery):
+            return f"({self._compile_select(source.query)}) AS {self._quote(source.alias)}"
+        raise TypeError(f"Unsupported source type: {type(source)}")
+
+    def _compile_table(self, table: Table) -> str:
+        if table.alias:
+            return f"{self._quote(table.name)} AS {self._quote(table.alias)}"
+        return self._quote(table.name)
+
+    def _compile_expr(self, expr: Any) -> str:
+        if isinstance(expr, Column):
+            return self._compile_column(expr)
+        if isinstance(expr, AliasExpr):
+            return f"{self._compile_expr(expr.expr)} AS {self._quote(expr.alias)}"
+        if isinstance(expr, Function):
+            args = ", ".join(self._compile_expr(a) for a in expr.args)
+            return f"{expr.name}({args})"
+        if isinstance(expr, OrderSpec):
+            return self._compile_order(expr)
+        if isinstance(expr, Literal):
+            return self._bind(expr.value)
+        if isinstance(expr, ast.Subquery):
+            return f"({self._compile_select(expr.query)})"
+        return self._compile_predicate(expr)
+
+    def _compile_predicate(self, pred: Predicate) -> str:
+        if isinstance(pred, BinaryPredicate):
+            return f"{self._compile_expr(pred.left)} {pred.op} {self._compile_expr(pred.right)}"
+        if isinstance(pred, UnaryPredicate):
+            return f"{self._compile_expr(pred.expr)} {pred.op}"
+        if isinstance(pred, LogicalPredicate):
+            inner = f" {pred.op} ".join(self._compile_predicate(p) for p in pred.predicates)
+            return f"({inner})"
+        if isinstance(pred, NotPredicate):
+            return f"NOT ({self._compile_predicate(pred.predicate)})"
+        raise TypeError(f"Unsupported predicate type: {type(pred)}")
+
+    def _compile_and_list(self, preds: Iterable[Predicate]) -> str:
+        parts = [self._compile_predicate(p) for p in preds]
+        return " AND ".join(parts)
+
+    def _compile_order(self, order: OrderSpec) -> str:
+        return f"{self._compile_expr(order.expr)} {order.direction}"
+
+    def _compile_column(self, col: Column) -> str:
+        if col.table.alias:
+            return f"{self._quote(col.table.alias)}.{self._quote(col.name)}"
+        return f"{self._quote(col.table.name)}.{self._quote(col.name)}"
+
+    def _quote(self, ident: str) -> str:
+        escaped = ident.replace('"', '""')
+        return f'"{escaped}"'
+
+    def _bind(self, value: Any) -> str:
+        name = f"p{self._param_index}"
+        self._param_index += 1
+        self.params[name] = value
+        return f":{name}"