pydoptic-sql 0.0.1.post1.dev2__tar.gz

pydoptic_sql-0.0.1.post1.dev2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Hungerford
+
+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.

pydoptic_sql-0.0.1.post1.dev2/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: pydoptic-sql
+Version: 0.0.1.post1.dev2
+Summary: A type-safe SQL query builder built on pydoptic
+Author: John Hungerford
+License-Expression: MIT
+Project-URL: Source, https://github.com/johnhungerford/pydoptic
+Requires-Python: <3.14,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydoptic
+Requires-Dist: psycopg[binary]==3.2.12
+Provides-Extra: test
+Requires-Dist: pytest~=8.4.2; extra == "test"
+Provides-Extra: types
+Requires-Dist: mypy~=1.18.2; extra == "types"
+Dynamic: license-file
+
+# pydoptic-sql
+
+A type-safe SQL query builder built on [pydoptic](https://pypi.org/project/pydoptic/).
+
+Join arity is tracked in the type system itself, so a WHERE/ON/HAVING clause can't reference a table
+that isn't actually in scope at that point in a join chain -- mypy catches it, not just Postgres at
+runtime.
+
+## Installation
+
+```bash
+pip install pydoptic-sql
+```
+
+Includes `psycopg` as a regular dependency, so no extras are needed to execute queries against
+Postgres.
+
+## Quickstart
+
+```python3
+from pydoptic import Prop
+from pydoptic_sql import SqlTable, ColumnType, PrimaryKey, column, SqlQuery, Constraint, PsycoPgSqlClient
+import psycopg
+
+class Worker(SqlTable):
+    id: Prop['Worker', int] = column(type=ColumnType.BIGINT(), constraints=[PrimaryKey])
+    name: Prop['Worker', str] = column(type=ColumnType.TEXT())
+    age: Prop['Worker', int] = column(type=ColumnType.INT())
+    department_id: Prop['Worker', int] = column(type=ColumnType.BIGINT())
+
+query = SqlQuery.from_table(Worker).select(Worker.name).where(Constraint.gte(Worker.age, 18))
+
+with psycopg.connect("host=localhost dbname=mydb user=postgres password=password") as conn:
+    client = PsycoPgSqlClient(conn)
+    with client.open() as tx:
+        for worker in tx.execute(query).stream():
+            print(Worker.name.get_val_safe(worker))
+```
+
+Joining a second table narrows and widens the query's type together -- `Constraint2` (not
+`Constraint`) is required for a WHERE/ON clause once a second table is in scope, and can reference
+either table directly:
+
+```python3
+class Department(SqlTable):
+    id: Prop['Department', int] = column(type=ColumnType.BIGINT(), constraints=[PrimaryKey])
+    name: Prop['Department', str] = column(type=ColumnType.TEXT())
+
+from pydoptic_sql import Constraint2
+
+query = SqlQuery.from_table(Worker).join_inner(
+    Department, Constraint2.eq(Worker.department_id, Department.id),
+).select(Worker.name, Department.name).where(Constraint2.gte(Worker.age, 18))
+```
+
+See the [pydoptic README](https://github.com/johnhungerford/pydoptic/tree/main/packages/pydoptic) for
+the underlying `Prop`/`Select` model this is built on.

pydoptic_sql-0.0.1.post1.dev2/README.md

@@ -0,0 +1,57 @@
+# pydoptic-sql
+
+A type-safe SQL query builder built on [pydoptic](https://pypi.org/project/pydoptic/).
+
+Join arity is tracked in the type system itself, so a WHERE/ON/HAVING clause can't reference a table
+that isn't actually in scope at that point in a join chain -- mypy catches it, not just Postgres at
+runtime.
+
+## Installation
+
+```bash
+pip install pydoptic-sql
+```
+
+Includes `psycopg` as a regular dependency, so no extras are needed to execute queries against
+Postgres.
+
+## Quickstart
+
+```python3
+from pydoptic import Prop
+from pydoptic_sql import SqlTable, ColumnType, PrimaryKey, column, SqlQuery, Constraint, PsycoPgSqlClient
+import psycopg
+
+class Worker(SqlTable):
+    id: Prop['Worker', int] = column(type=ColumnType.BIGINT(), constraints=[PrimaryKey])
+    name: Prop['Worker', str] = column(type=ColumnType.TEXT())
+    age: Prop['Worker', int] = column(type=ColumnType.INT())
+    department_id: Prop['Worker', int] = column(type=ColumnType.BIGINT())
+
+query = SqlQuery.from_table(Worker).select(Worker.name).where(Constraint.gte(Worker.age, 18))
+
+with psycopg.connect("host=localhost dbname=mydb user=postgres password=password") as conn:
+    client = PsycoPgSqlClient(conn)
+    with client.open() as tx:
+        for worker in tx.execute(query).stream():
+            print(Worker.name.get_val_safe(worker))
+```
+
+Joining a second table narrows and widens the query's type together -- `Constraint2` (not
+`Constraint`) is required for a WHERE/ON clause once a second table is in scope, and can reference
+either table directly:
+
+```python3
+class Department(SqlTable):
+    id: Prop['Department', int] = column(type=ColumnType.BIGINT(), constraints=[PrimaryKey])
+    name: Prop['Department', str] = column(type=ColumnType.TEXT())
+
+from pydoptic_sql import Constraint2
+
+query = SqlQuery.from_table(Worker).join_inner(
+    Department, Constraint2.eq(Worker.department_id, Department.id),
+).select(Worker.name, Department.name).where(Constraint2.gte(Worker.age, 18))
+```
+
+See the [pydoptic README](https://github.com/johnhungerford/pydoptic/tree/main/packages/pydoptic) for
+the underlying `Prop`/`Select` model this is built on.

pydoptic_sql-0.0.1.post1.dev2/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pydoptic-sql"
+dynamic = ["version"]
+authors = [{ name = "John Hungerford" }]
+urls = { Source = "https://github.com/johnhungerford/pydoptic" }
+description = "A type-safe SQL query builder built on pydoptic"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.8,<3.14"
+dependencies = [
+    "pydoptic",
+    "psycopg[binary]==3.2.12",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest~=8.4.2",
+]
+types = [
+    "mypy~=1.18.2",
+]
+
+[tool.setuptools_scm]
+# See packages/pydoptic/pyproject.toml -- same repo-wide lockstep version, same reasoning.
+root = "../.."
+version_scheme = "no-guess-dev"
+local_scheme = "no-local-version"
+
+[tool.pytest.ini_options]
+markers = [
+    "integration: requires a live Postgres instance started via docker-compose.yml; excluded by default, opt in with `-m integration`",
+]
+addopts = "-m 'not integration'"

pydoptic_sql-0.0.1.post1.dev2/setup.cfg

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

pydoptic_sql-0.0.1.post1.dev2/src/pydoptic_sql/__init__.py

@@ -0,0 +1,49 @@
+from pydoptic_sql.sql_table import (
+    AutoIncrement,
+    Check,
+    ColumnConstraint,
+    ColumnInfo,
+    ColumnType,
+    Default,
+    ForeignKey,
+    ManualColumnConstraint,
+    PrimaryKey,
+    SqlTable,
+    Unique,
+    column,
+)
+from pydoptic_sql.sql_constraint import Comparison, Constraint, Constraint2, Constraint3, Constraint4
+from pydoptic_sql.sql_order import Direction, OrderBy
+from pydoptic_sql.sql_computed import AggregateFunction, Computed, ComputedResult
+from pydoptic_sql.sql_having import HavingConstraint, HavingConstraint2, HavingConstraint3, HavingConstraint4
+from pydoptic_sql.sql_query import (
+    ComputedQuery1,
+    ComputedQuery2,
+    ComputedQuery3,
+    ComputedQuery4,
+    CreateQuery,
+    DeleteQuery,
+    DropQuery,
+    InsertQuery,
+    JoinType,
+    Query1,
+    Query2,
+    Query3,
+    Query4,
+    SqlQuery,
+    UpdateQuery,
+)
+from pydoptic_sql.sql_service import PsycoPgSqlClient, SqlClient, SqlResponse, SqlTransaction
+
+__all__ = [
+    'AutoIncrement', 'Check', 'ColumnConstraint', 'ColumnInfo', 'ColumnType', 'Default', 'ForeignKey',
+    'ManualColumnConstraint', 'PrimaryKey', 'SqlTable', 'Unique', 'column',
+    'Comparison', 'Constraint', 'Constraint2', 'Constraint3', 'Constraint4',
+    'Direction', 'OrderBy',
+    'AggregateFunction', 'Computed', 'ComputedResult',
+    'HavingConstraint', 'HavingConstraint2', 'HavingConstraint3', 'HavingConstraint4',
+    'ComputedQuery1', 'ComputedQuery2', 'ComputedQuery3', 'ComputedQuery4',
+    'CreateQuery', 'DeleteQuery', 'DropQuery', 'InsertQuery', 'JoinType',
+    'Query1', 'Query2', 'Query3', 'Query4', 'SqlQuery', 'UpdateQuery',
+    'PsycoPgSqlClient', 'SqlClient', 'SqlResponse', 'SqlTransaction',
+]

pydoptic_sql-0.0.1.post1.dev2/src/pydoptic_sql/sql_computed.py

@@ -0,0 +1,93 @@
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Generic, Mapping, Type, TypeVar
+
+from pydoptic.selector import Prop, PropOpt, SelectVal, SelectValue, Selectable
+from pydoptic_sql import SqlTable
+
+TC = TypeVar('TC', bound=SqlTable, contravariant=True)
+A = TypeVar('A')
+
+class AggregateFunction(Enum):
+    SUM = 'SUM'
+    COUNT = 'COUNT'
+    AVG = 'AVG'
+    MIN = 'MIN'
+    MAX = 'MAX'
+
+class ComputedResult(Selectable['ComputedResult']):
+    """
+    Dict-backed holder for the computed (aggregate) columns of a query result row, keyed by each
+    `Computed`'s alias. Mirrors `PartialModel`'s shape but isn't backed by a model class -- there's
+    no schema behind an aggregate expression, just whatever aliases the query selected.
+    """
+    __slots__ = ['_dict']
+    _dict: Dict[str, Any]
+
+    def __init__(self, **kwargs: Any):
+        object.__setattr__(self, '_dict', dict(kwargs))
+
+    def __repr__(self) -> str:
+        return 'ComputedResult(' + ', '.join(f'{k}={v}' for k, v in self._dict.items()) + ')'
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, ComputedResult) and self._dict == other._dict
+
+    def __getattr__(self, item: str) -> Any:
+        try:
+            return object.__getattribute__(self, '_dict')[item]
+        except KeyError:
+            raise AttributeError(item)
+
+    def as_dict(self) -> Mapping[str, Any]:
+        return self._dict
+
+@dataclass(frozen=True, slots=True)
+class Computed(Generic[TC, A], SelectVal[ComputedResult, A]):
+    """
+    An aggregate expression (SUM/COUNT/AVG/MIN/MAX) over a column, constructed via `SqlQuery.sum`/
+    `.count`/etc., selected into a query via `select_computed`/`select_computed_more`, and extracted
+    from a `ComputedResult` via `get_val`/`get_val_safe` -- same as a plain `Prop` extracts a value
+    from a model. `column` is `None` only for `SqlQuery.count(table)` (`COUNT(*)`), which doesn't
+    reference any particular column.
+
+    `TC` is phantom bookkeeping, not part of the `Select[ComputedResult, A]` shape it's used as --
+    it exists purely so `select_computed_more`'s signature can restrict which joined table(s) a given
+    `Computed` may reference, the same way `OrderBy`'s `TC` does. Like `OrderBy`, `Computed` has no
+    arity variants of its own: a joined query's computed selection is typed as a union of
+    `Computed[<each joined table>, Any]`, so an entry set for one table stays valid unchanged as more
+    tables get joined in, and qualification (`table.column` vs. bare) is decided by whichever class
+    renders it, not by `Computed` itself.
+    """
+    column: Prop[TC, Any] | PropOpt[TC, Any] | None
+    function: AggregateFunction
+    label: str
+    _target: Type[A]
+
+    @property
+    def origin(self) -> Type[ComputedResult]:
+        return ComputedResult
+
+    @property
+    def target(self) -> Type[A]:
+        return self._target
+
+    def get_unsafe(self, value: 'Selectable[ComputedResult] | Dict[str, Any]') -> SelectValue[A]:
+        if isinstance(value, dict):
+            if self.label not in value:
+                raise ValueError(f'Unexpected empty value for computed column {self.label}')
+            result = value[self.label]
+        else:
+            try:
+                result = getattr(value, self.label)
+            except AttributeError:
+                raise ValueError(f'Unexpected empty value for computed column {self.label}')
+        return SelectValue(result, False, False)
+
+    def get(self, value: ComputedResult) -> SelectValue[A]:
+        return SelectValue(getattr(value, self.label), False, False)
+
+    def to_sql(self) -> str:
+        col_ref = '*' if self.column is None else self.column.label
+        return f'{self.function.value}({col_ref}) AS {self.label}'