diff --git a/.changes/unreleased/Added-20260722-120000.yaml b/.changes/unreleased/Added-20260722-120000.yaml new file mode 100644 index 00000000..79e5f669 --- /dev/null +++ b/.changes/unreleased/Added-20260722-120000.yaml @@ -0,0 +1,6 @@ +kind: Added +body: 'Psycopg 3 support: the new `sql_driver` value `psycopg_async` generates asyncio code for `psycopg` with the same commands as asyncpg, including `:copyfrom` via `cursor.copy()`. Queries are rewritten to psycopg''s named pyformat placeholders at generation time and bind their parameters as a dict, the type contract matches asyncpg exactly (returned `json`/`jsonb` columns stay `str` via a registered raw-text loader, so converters behave identically), and the generated code passes pyright strict against psycopg''s `LiteralString` query typing. Requires `psycopg >= 3.2`.' +time: 2026-07-22T12:00:00.0000000Z +custom: + Author: Rayakame + PR: "217" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0317d3fb..ac9ffd5b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -175,6 +175,29 @@ jobs: - name: Run sqlc verify via nox run: | uv run nox -s asyncpg_check + psycopg-async: + runs-on: ubuntu-latest + name: "Run psycopg_async check via nox" + permissions: + contents: read + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: Install uv + uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0 + with: + version: "0.11.31" + python-version: "3.13" + + - name: Install sqlc + uses: sqlc-dev/setup-sqlc@bac53b7fb28c039a6c7f5736fd1e89744021bdd6 # v5 + with: + sqlc-version: '1.31.1' + + - name: Run sqlc verify via nox + run: | + uv run nox -s psycopg_async_check aiosqlite: runs-on: ubuntu-latest @@ -292,7 +315,7 @@ jobs: retention-days: 30 ci-done: - needs: [ test, upload-coverage, asyncpg, aiosqlite, sqlite3, pyright, ruff, go-test, go-lint, test-build ] + needs: [ test, upload-coverage, asyncpg, psycopg-async, aiosqlite, sqlite3, pyright, ruff, go-test, go-lint, test-build ] if: always() && !cancelled() runs-on: ubuntu-latest diff --git a/README.md b/README.md index e07fd3b9..fb4dc2c2 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,8 @@ and the full plugin option list in the - **Four model types** - `dataclass`, `attrs`, `msgspec`, or `pydantic` ([docs](https://rayakame.github.io/sqlc-gen-better-python/docs/guide/model-types/)). -- **Three drivers** - `asyncpg` for PostgreSQL, `aiosqlite` and `sqlite3` for SQLite +- **Four drivers** - `asyncpg` and `psycopg_async` for PostgreSQL, `aiosqlite` + and `sqlite3` for SQLite ([docs](https://rayakame.github.io/sqlc-gen-better-python/docs/guide/drivers/)). - **Typed query functions** - one module per query file, one function per query ([docs](https://rayakame.github.io/sqlc-gen-better-python/docs/guide/writing-queries/)). diff --git a/docs/content/_index.md b/docs/content/_index.md index e18e8e23..4fae67c7 100644 --- a/docs/content/_index.md +++ b/docs/content/_index.md @@ -34,9 +34,9 @@ layout: hextra-home subtitle="Generate dataclass, attrs, msgspec, or pydantic models - pick per codegen block." >}} {{< hextra/feature-card - title="Three drivers" + title="Four drivers" link="docs/guide/drivers" - subtitle="asyncpg for PostgreSQL, plus aiosqlite and sqlite3 for SQLite." + subtitle="asyncpg and psycopg for PostgreSQL, plus aiosqlite and sqlite3 for SQLite." >}} {{< hextra/feature-card title="Strictly typed output" diff --git a/docs/content/docs/_index.md b/docs/content/docs/_index.md index 40737bda..9fb9e79f 100644 --- a/docs/content/docs/_index.md +++ b/docs/content/docs/_index.md @@ -21,7 +21,7 @@ it. ## Explore by feature {{< cards >}} - {{< card link="guide/drivers" title="Drivers" icon="database" subtitle="asyncpg, aiosqlite, and sqlite3." >}} + {{< card link="guide/drivers" title="Drivers" icon="database" subtitle="asyncpg, psycopg, aiosqlite, and sqlite3." >}} {{< card link="guide/model-types" title="Model types" icon="cube" subtitle="dataclass, attrs, msgspec, or pydantic." >}} {{< card link="guide/writing-queries" title="Writing queries" icon="code" subtitle="How query annotations become typed functions." >}} {{< card link="guide/enums" title="Enums" icon="collection" subtitle="PostgreSQL enums as enum.StrEnum classes." >}} @@ -37,7 +37,7 @@ it. |---|---| | **Python** | 3.12 or newer | | **Engines** | PostgreSQL, SQLite | -| **Drivers** | `asyncpg`, `aiosqlite`, `sqlite3` | +| **Drivers** | `asyncpg`, `psycopg_async`, `aiosqlite`, `sqlite3` | | **Model types** | `dataclass`, `attrs`, `msgspec`, `pydantic` | | **Docstrings** | `google`, `numpy`, `pep257`, or none | | **Checked with** | pyright (strict) and ruff | diff --git a/docs/content/docs/getting-started.md b/docs/content/docs/getting-started.md index de93ada5..3e6c8365 100644 --- a/docs/content/docs/getting-started.md +++ b/docs/content/docs/getting-started.md @@ -28,6 +28,14 @@ pip install asyncpg {{< /tab >}} + {{< tab name="psycopg_async" >}} + +```bash +pip install "psycopg[binary]" +``` + + {{< /tab >}} + {{< tab name="aiosqlite" >}} ```bash @@ -79,6 +87,32 @@ sql: {{< /tab >}} + {{< tab name="psycopg_async" >}} + +```yaml +# filename: sqlc.yaml +version: "2" +plugins: + - name: python + wasm: + url: https://github.com/rayakame/sqlc-gen-better-python/releases/download/v0.6.0/sqlc-gen-better-python.wasm + sha256: 16f5affb502f2ec65ca61f6fc5ddd993449c4a4fc281996c3c9a9bc2e35b1474 +sql: + - engine: "postgresql" + queries: "query.sql" + schema: "schema.sql" + codegen: + - out: "app/db" + plugin: python + options: + package: "db" + emit_init_file: true + sql_driver: "psycopg_async" + model_type: "dataclass" +``` + + {{< /tab >}} + {{< tab name="aiosqlite" >}} ```yaml @@ -147,6 +181,19 @@ sql: {{< tab name="asyncpg" >}} +```sql +-- filename: schema.sql +CREATE TABLE users +( + id bigint PRIMARY KEY NOT NULL, + name text NOT NULL +); +``` + + {{< /tab >}} + + {{< tab name="psycopg_async" >}} + ```sql -- filename: schema.sql CREATE TABLE users @@ -201,6 +248,19 @@ returns a single row or `None`, `:many` returns all matching rows. -- name: GetUser :one SELECT * FROM users WHERE id = $1; +-- name: ListUsers :many +SELECT * FROM users ORDER BY name; +``` + + {{< /tab >}} + + {{< tab name="psycopg_async" >}} + +```sql +-- filename: query.sql +-- name: GetUser :one +SELECT * FROM users WHERE id = $1; + -- name: ListUsers :many SELECT * FROM users ORDER BY name; ``` @@ -236,6 +296,8 @@ SELECT * FROM users ORDER BY name; {{< /tabs >}} PostgreSQL uses `$1` placeholders, SQLite uses `?`. Everything else is the same. +(You write `$1` for psycopg too - the plugin rewrites the placeholders to +psycopg's format at generation time.) ## 4. Generate @@ -272,6 +334,30 @@ async def get_user(conn: ConnectionLike, *, id_: int) -> models.User | None: return models.User(id_=row[0], name=row[1]) +def list_users(conn: ConnectionLike) -> QueryResults[models.User]: + ... +``` + + {{< /tab >}} + + {{< tab name="psycopg_async" >}} + +```python +# models.py +@dataclasses.dataclass() +class User: + id_: int + name: str + + +# query.py +async def get_user(conn: ConnectionLike, *, id_: int) -> models.User | None: + row = await (await conn.execute(GET_USER, {"p1": id_})).fetchone() + if row is None: + return None + return models.User(id_=row[0], name=row[1]) + + def list_users(conn: ConnectionLike) -> QueryResults[models.User]: ... ``` @@ -366,6 +452,35 @@ async def main() -> None: print(user.name) +asyncio.run(main()) +``` + + {{< /tab >}} + + {{< tab name="psycopg_async" >}} + +```python +import asyncio + +import psycopg + +from app.db import query + + +async def main() -> None: + async with await psycopg.AsyncConnection.connect("postgresql://user:pass@localhost/mydb") as conn: + user = await query.get_user(conn, id_=1) + if user is not None: + print(user.name) + + # every row at once + users = await query.list_users(conn) + + # or iterate + async for user in query.list_users(conn): + print(user.name) + + asyncio.run(main()) ``` diff --git a/docs/content/docs/guide/_index.md b/docs/content/docs/guide/_index.md index 098d88f3..fc4cc6db 100644 --- a/docs/content/docs/guide/_index.md +++ b/docs/content/docs/guide/_index.md @@ -37,7 +37,7 @@ Start with the essentials, then dip into feature pages as you need them: {{< cards >}} {{< card link="configuration" title="Configuration" subtitle="The sqlc.yaml plugin block and the core options." >}} - {{< card link="drivers" title="Drivers" subtitle="asyncpg, aiosqlite, and sqlite3 - and which query commands each supports." >}} + {{< card link="drivers" title="Drivers" subtitle="asyncpg, psycopg, aiosqlite, and sqlite3 - and which query commands each supports." >}} {{< card link="model-types" title="Model types" subtitle="dataclass, attrs, msgspec, or pydantic models." >}} {{< card link="writing-queries" title="Writing queries" subtitle="How query annotations become typed Python functions." >}} {{< /cards >}} diff --git a/docs/content/docs/guide/configuration.md b/docs/content/docs/guide/configuration.md index 231e231f..a10cb225 100644 --- a/docs/content/docs/guide/configuration.md +++ b/docs/content/docs/guide/configuration.md @@ -54,7 +54,7 @@ sql: | Option | What it does | |---|---| | `package` | The name of the generated package. | -| `sql_driver` | `asyncpg`, `aiosqlite`, or `sqlite3` - must match the `engine`. See [Drivers](/docs/guide/drivers). | +| `sql_driver` | `asyncpg`, `psycopg_async`, `aiosqlite`, or `sqlite3` - must match the `engine`. See [Drivers](/docs/guide/drivers). | | `emit_init_file` | Whether to emit `__init__.py`. Must be set explicitly. | Everything else is optional and has a sensible default. The most common ones to @@ -88,8 +88,9 @@ queries - for example a `msgspec` package and a `dataclass` package: ## Common pitfalls -- **Driver/engine mismatch.** `sql_driver: asyncpg` requires `engine: "postgresql"`; - `aiosqlite`/`sqlite3` require `engine: "sqlite"`. A mismatch is an error. +- **Driver/engine mismatch.** `sql_driver: asyncpg` and `psycopg_async` require + `engine: "postgresql"`; `aiosqlite`/`sqlite3` require `engine: "sqlite"`. A + mismatch is an error. - **Forgetting `emit_init_file`.** It has no default and generation fails if it is omitted. Set it to `true` unless the package already has an `__init__.py`. - **A stale `sha256`.** When you bump the plugin version, update the hash too. diff --git a/docs/content/docs/guide/drivers.md b/docs/content/docs/guide/drivers.md index 1e931258..1138924c 100644 --- a/docs/content/docs/guide/drivers.md +++ b/docs/content/docs/guide/drivers.md @@ -6,17 +6,23 @@ next: /docs/guide/model-types --- The `sql_driver` option picks which database library the generated code targets. -It must match your `engine`. Three drivers are supported: +It must match your `engine`. Four drivers are supported: | Driver | Engine | Style | |---|---|---| | `asyncpg` | `postgresql` | async | +| `psycopg_async` | `postgresql` | async | | `aiosqlite` | `sqlite` | async | | `sqlite3` | `sqlite` | sync | Every generated query function takes the connection as its first argument, so you open and manage the connection yourself and pass it in. +Both PostgreSQL drivers produce the same models and type contract, so choosing +between them is about the driver itself: pick `asyncpg` when raw driver +throughput is the priority, and `psycopg_async` to stay in the psycopg +ecosystem (libpq, pipeline mode, PgBouncer friendliness) at comparable speed. + ## asyncpg (PostgreSQL) ```python @@ -35,8 +41,40 @@ async def main() -> None: asyncio.run(main()) ``` -asyncpg is the only driver that supports `:copyfrom` (bulk insert via -`copy_records_to_table`). +asyncpg supports `:copyfrom` (bulk insert via `copy_records_to_table`). + +## psycopg_async (PostgreSQL) + +```python +import asyncio + +import psycopg + +from app.db import queries + + +async def main() -> None: + conn = await psycopg.AsyncConnection.connect("postgresql://user:pass@localhost/db") + user = await queries.get_field_naming(conn, id_=1) + + +asyncio.run(main()) +``` + +The generated code targets [Psycopg 3](https://www.psycopg.org/psycopg3/) +(3.2 or newer) with its default tuple rows - the connection annotation is +`psycopg.AsyncConnection[psycopg.rows.TupleRow]`, so a connection configured +with another row factory is rejected by pyright. `:copyfrom` streams rows +through `cursor.copy()`. + +{{< callout type="info" >}} + Modules returning `json`/`jsonb` columns register a raw-text loader on + psycopg's process-global adapters map at import time, so those columns stay + `str` exactly like on asyncpg - including for + [converters](/docs/guide/converters). On Windows, psycopg's async support + requires the `SelectorEventLoop`; the default `ProactorEventLoop` is + rejected. +{{< /callout >}} ## aiosqlite (async SQLite) @@ -80,5 +118,5 @@ user = queries.get_field_naming(conn, id_=1) ## Command support Not every [query command](/docs/guide/writing-queries) works on every driver - -for example `:copyfrom` is asyncpg-only and `:execlastid` is SQLite-only. The +for example `:copyfrom` is PostgreSQL-only and `:execlastid` is SQLite-only. The full matrix is in the [feature support reference](/docs/reference/feature-support). diff --git a/docs/content/docs/guide/enums.md b/docs/content/docs/guide/enums.md index 26ed966d..550fd83d 100644 --- a/docs/content/docs/guide/enums.md +++ b/docs/content/docs/guide/enums.md @@ -64,5 +64,5 @@ from a `public.mood` that would become `Mood`. {{< callout type="info" >}} Enum classes are a PostgreSQL feature - SQLite has no native enum type, so this - applies to the `asyncpg` driver. + applies to the PostgreSQL drivers (`asyncpg` and `psycopg_async`). {{< /callout >}} diff --git a/docs/content/docs/guide/writing-queries.md b/docs/content/docs/guide/writing-queries.md index 7f4dd034..a5313dd4 100644 --- a/docs/content/docs/guide/writing-queries.md +++ b/docs/content/docs/guide/writing-queries.md @@ -104,22 +104,23 @@ async def set_field_naming_outputs(conn: ConnectionLike, *, id_: int, outputs: s Variants of `:exec` that return something about the write: - **`:execrows`** - the number of affected rows (`int`). For statements that - affect no rows, such as `CREATE TABLE`, asyncpg reports `0` and the SQLite - drivers report `-1`. + affect no rows, such as `CREATE TABLE`, asyncpg reports `0` while psycopg and + the SQLite drivers report `-1`. - **`:execlastid`** - the cursor's `lastrowid`, typed `int | None` - it is `None` when no row was affected. SQLite drivers only, and note it is the last *affected* row, not strictly the last inserted one. - **`:execresult`** - the driver's raw result, which differs per driver: a `str` - status tag on asyncpg, and a `sqlite3.Cursor` / `aiosqlite.Cursor` on the - SQLite drivers. + status tag on asyncpg, a `psycopg.AsyncCursor` on psycopg, and a + `sqlite3.Cursor` / `aiosqlite.Cursor` on the SQLite drivers. See the [feature support matrix](/docs/reference/feature-support) for which driver supports which. ### `:copyfrom` -asyncpg only. Bulk-inserts rows via `copy_records_to_table`, taking a sequence of -generated `Params` objects and returning the affected row count: +PostgreSQL drivers only. Bulk-inserts rows, taking a sequence of generated +`Params` objects and returning the affected row count. asyncpg goes +through `copy_records_to_table`: ```python async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: @@ -128,6 +129,22 @@ async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequen return int(n) if (p := r.split()) and (n := p[-1]).isdigit() else 0 ``` +psycopg streams the rows through `cursor.copy()` instead: + +```python +async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount +``` + +Looking for prepared queries? Every supported driver prepares statements +automatically - see +[prepared queries](/docs/reference/feature-support#prepared-queries) in the +feature support reference for the per-driver details. + ## Parameters By default every parameter is **keyword-only** (note the `*,` in the signatures diff --git a/docs/content/docs/reference/configuration-options.md b/docs/content/docs/reference/configuration-options.md index f3543a0d..66cb09d0 100644 --- a/docs/content/docs/reference/configuration-options.md +++ b/docs/content/docs/reference/configuration-options.md @@ -17,7 +17,7 @@ optional. | Option | Type | Default | Description | |---|---|---|---| | `package` | string | *required* | Name of the generated package. | -| `sql_driver` | string | *required* | One of `asyncpg`, `aiosqlite`, `sqlite3`. Must match the engine (`asyncpg` -> `postgresql`; the other two -> `sqlite`). | +| `sql_driver` | string | *required* | One of `asyncpg`, `psycopg_async`, `aiosqlite`, `sqlite3`. Must match the engine (the postgres drivers -> `postgresql`; the sqlite drivers -> `sqlite`). | | `emit_init_file` | bool | *required* | Whether to emit an `__init__.py` in the package. Must be set explicitly. Set `false` only if the package already has one. | | `model_type` | string | `dataclass` | One of `dataclass`, `attrs`, `msgspec`, `pydantic`. See [Model types](/docs/guide/model-types). | | `initialisms` | list[string] | `["id"]` | Identifier segments to upper-case, e.g. `app_id` -> `AppID`. | diff --git a/docs/content/docs/reference/feature-support.md b/docs/content/docs/reference/feature-support.md index 1b98903d..4ce8d482 100644 --- a/docs/content/docs/reference/feature-support.md +++ b/docs/content/docs/reference/feature-support.md @@ -25,29 +25,69 @@ supported (`sqlc.arg`, `sqlc.narg`, `sqlc.embed`, `sqlc.slice`). The supported [query annotations](https://docs.sqlc.dev/en/latest/reference/query-annotations.html) depend on the driver: -| Command | aiosqlite | sqlite3 | asyncpg | -|---|---|---|---| -| `:one` | yes | yes | yes | -| `:many` | yes | yes | yes | -| `:exec` | yes | yes | yes | -| `:execresult` | yes | yes | yes | -| `:execrows` | yes | yes | yes | -| `:execlastid` | yes | yes | no | -| `:copyfrom` | no | no | yes | +| Command | aiosqlite | sqlite3 | asyncpg | psycopg_async | +|---|---|---|---|---| +| `:one` | yes | yes | yes | yes | +| `:many` | yes | yes | yes | yes | +| `:exec` | yes | yes | yes | yes | +| `:execresult` | yes | yes | yes | yes | +| `:execrows` | yes | yes | yes | yes | +| `:execlastid` | yes | yes | no | no | +| `:copyfrom` | no | no | yes | yes | See [Writing queries](/docs/guide/writing-queries) for what each command generates. {{< callout type="info" >}} - `:execlastid` relies on a last-inserted-row id, which asyncpg/PostgreSQL do not + `:execlastid` relies on a last-inserted-row id, which PostgreSQL does not provide; use a `RETURNING` clause with `:one` instead. `:copyfrom` maps to - asyncpg's bulk `copy_records_to_table`, which the SQLite drivers have no - equivalent for. + PostgreSQL's bulk `COPY` protocol (`copy_records_to_table` on asyncpg, + `cursor.copy()` on psycopg), which the SQLite drivers have no equivalent for. +{{< /callout >}} + +### Prepared queries + +Coming from sqlc's Go workflow you might look for an +[`emit_prepared_queries`](https://docs.sqlc.dev/en/latest/howto/prepared_query.html) +equivalent. There is none, on purpose: every supported Python driver already +prepares statements automatically, so the generated code gets prepared-query +performance without any extra codegen. What differs per driver is *when* a +query gets prepared and which knob controls it: + +- **asyncpg** prepares every query it runs and keeps it in a per-connection + LRU statement cache (100 entries by default). Tune it at connect time: + + ```python + conn = await asyncpg.connect( + dsn, + statement_cache_size=200, # default 100; 0 disables the cache + ) + ``` + +- **psycopg** prepares a query server-side once it has been executed more than + `prepare_threshold` times on the connection - with the default of 5, the + sixth execution is the first prepared one. Set it to `0` to prepare from the + first execution, or `None` to never prepare: + + ```python + conn = await psycopg.AsyncConnection.connect(dsn, prepare_threshold=0) + ``` + +- **sqlite3 / aiosqlite** expose no explicit prepare API, but the `sqlite3` + module compiles each statement once and reuses it through an internal + per-connection cache (128 entries by default). Raise it with the + `cached_statements` argument of `connect()` if you have more distinct + queries than that. + +{{< callout type="warning" >}} + Behind PgBouncer in transaction-pooling mode, server-side prepared + statements belong to a connection you do not control. Disable them there: + `statement_cache_size=0` for asyncpg, `prepare_threshold=None` for psycopg. {{< /callout >}} ## Not supported - **`:batch*` commands** (`:batchexec`, `:batchmany`, `:batchone`) are not supported and likely never will be. -- **Prepared queries** are not planned for the near future. -- **`psycopg2` and `mysql`** drivers are not currently supported. +- **`psycopg2` and `mysql`** drivers are not currently supported; Psycopg 3 + is, via the async `psycopg_async` driver. diff --git a/internal/config/constants.go b/internal/config/constants.go index e2164a61..4ea03ce6 100644 --- a/internal/config/constants.go +++ b/internal/config/constants.go @@ -15,9 +15,10 @@ func (dr SQLDriver) String() string { } const ( - SQLDriverSQLite SQLDriver = "sqlite3" - SQLDriverAioSQLite SQLDriver = "aiosqlite" - SQLDriverAsyncpg SQLDriver = "asyncpg" + SQLDriverSQLite SQLDriver = "sqlite3" + SQLDriverAioSQLite SQLDriver = "aiosqlite" + SQLDriverAsyncpg SQLDriver = "asyncpg" + SQLDriverPsycopgAsync SQLDriver = "psycopg_async" ) const ( @@ -28,9 +29,10 @@ const ( ) var driversEngine = map[SQLDriver]string{ - SQLDriverSQLite: "sqlite", - SQLDriverAioSQLite: "sqlite", - SQLDriverAsyncpg: "postgresql", + SQLDriverSQLite: "sqlite", + SQLDriverAioSQLite: "sqlite", + SQLDriverAsyncpg: "postgresql", + SQLDriverPsycopgAsync: "postgresql", } const ( diff --git a/internal/driver/asyncpg.go b/internal/driver/asyncpg.go index a4869995..dac446d8 100644 --- a/internal/driver/asyncpg.go +++ b/internal/driver/asyncpg.go @@ -76,21 +76,9 @@ func (d *AsyncpgDriver) WriteQueryResultsClass(body *writer.CodeWriter) string { "result = await self._conn.fetch(self._sql, *self._args)", decodeRowsExpr, }) - body.NewLine() - body.WriteIndentedLine(1, "async def __anext__(self) -> T:") - body.WriteQueryResultsNextDocstring("an asyncpg cursor", d.IsAsync()) - body.WriteIndentedLine(2, "if self._cursor is None or self._iterator is None:") - body.WriteIndentedLine(3, "self._cursor = self._conn.cursor(self._sql, *self._args)") - body.WriteIndentedLine(3, "self._iterator = self._cursor.__aiter__()") - body.WriteIndentedLine(2, "try:") - body.WriteIndentedLine(3, "record = await self._iterator.__anext__()") - body.WriteIndentedLine(2, "except StopAsyncIteration:") - body.WriteIndentedLine(3, "self._cursor = None") - body.WriteIndentedLine(3, "self._iterator = None") - body.WriteIndentedLine(3, "raise") - body.WriteIndentedLine(2, "return self._decode_hook(record)") - - return "QueryResults" + writeAsyncNextMethod(body, "an asyncpg cursor", "self._cursor = self._conn.cursor(self._sql, *self._args)") + + return queryResultsClassName } // SupportsCommand returns if the driver supports the command. diff --git a/internal/driver/common.go b/internal/driver/common.go index 6016d070..49148be4 100644 --- a/internal/driver/common.go +++ b/internal/driver/common.go @@ -284,6 +284,25 @@ func sliceParams(query model.Query) []sliceParam { return params } +// writeAsyncNextMethod writes the cursor-backed __anext__ shared by the async +// QueryResults classes: open the cursor lazily via cursorInit, forward one +// record, and reset both fields on exhaustion so iteration can restart. +func writeAsyncNextMethod(body *writer.CodeWriter, cursorDesc, cursorInit string) { + body.NewLine() + body.WriteIndentedLine(1, "async def __anext__(self) -> T:") + body.WriteQueryResultsNextDocstring(cursorDesc, true) + body.WriteIndentedLine(2, "if self._cursor is None or self._iterator is None:") + body.WriteIndentedLine(3, cursorInit) + body.WriteIndentedLine(3, "self._iterator = self._cursor.__aiter__()") + body.WriteIndentedLine(2, "try:") + body.WriteIndentedLine(3, "record = await self._iterator.__anext__()") + body.WriteIndentedLine(2, "except StopAsyncIteration:") + body.WriteIndentedLine(3, "self._cursor = None") + body.WriteIndentedLine(3, "self._iterator = None") + body.WriteIndentedLine(3, "raise") + body.WriteIndentedLine(2, "return self._decode_hook(record)") +} + // writeQueryDocstring writes the docstring for a generated query function. // retType is the type shown in the Returns section (driver-specific for some // commands); pass "" for commands without one (:exec). diff --git a/internal/driver/common_test.go b/internal/driver/common_test.go index d110b096..fd61bb54 100644 --- a/internal/driver/common_test.go +++ b/internal/driver/common_test.go @@ -659,3 +659,17 @@ func TestWriteExecRowsReturn(t *testing.T) { }) } } + +func TestPsycopgParamEntries(t *testing.T) { + t.Parallel() + query := model.Query{ + Params: []model.QueryValue{ + {}, + {Name: "name", Type: model.PyType{Type: "str", SQLType: "text"}, Number: 2}, + }, + } + want := []string{`"p2": name`} + if got := psycopgParamEntries(query); !slices.Equal(got, want) { + t.Errorf("psycopgParamEntries() = %q, want %q", got, want) + } +} diff --git a/internal/driver/driver.go b/internal/driver/driver.go index 75cdb472..be908a09 100644 --- a/internal/driver/driver.go +++ b/internal/driver/driver.go @@ -8,7 +8,10 @@ import ( "github.com/rayakame/sqlc-gen-better-python/internal/writer" ) -const decodeRowsExpr = "return [self._decode_hook(row) for row in result]" +const ( + decodeRowsExpr = "return [self._decode_hook(row) for row in result]" + queryResultsClassName = "QueryResults" +) type Driver interface { // Name returns the Python module name (e.g., "asyncpg", "aiosqlite", "sqlite3"). @@ -53,6 +56,8 @@ func New(conf *config.Config) (Driver, error) { switch conf.SqlDriver { case config.SQLDriverAsyncpg: return newAsyncpgDriver(), nil + case config.SQLDriverPsycopgAsync: + return newPsycopgDriver(), nil case config.SQLDriverAioSQLite: return newSqliteDriver("aiosqlite", true), nil case config.SQLDriverSQLite: diff --git a/internal/driver/psycopg.go b/internal/driver/psycopg.go new file mode 100644 index 00000000..2693a27e --- /dev/null +++ b/internal/driver/psycopg.go @@ -0,0 +1,393 @@ +package driver + +import ( + "fmt" + "slices" + "strings" + + "github.com/rayakame/sqlc-gen-better-python/internal/config" + "github.com/rayakame/sqlc-gen-better-python/internal/model" + "github.com/rayakame/sqlc-gen-better-python/internal/writer" + "github.com/sqlc-dev/plugin-sdk-go/metadata" +) + +const ( + psycopgConnType = "ConnectionLike" + psycopgResultType = "psycopg.rows.TupleRow" +) + +// psycopgBase is the driver implementation for psycopg (Psycopg 3). +type psycopgBase struct { + rows *RowBuilder +} + +var _ Driver = (*psycopgBase)(nil) + +// newPsycopgDriver creates the psycopg driver. Runtime value conversion is +// identical to asyncpg: bytea, inet, and cidr convert inline; json and jsonb +// keep their str wire type via registered loaders, see WriteConversionSetup. +func newPsycopgDriver() *psycopgBase { + return &psycopgBase{ + rows: newRowBuilder(asyncpgNeedsConversion), + } +} + +// Name returns the Python module name, "psycopg". +func (p *psycopgBase) Name() string { return "psycopg" } + +// ConnType returns "ConnectionLike". +func (p *psycopgBase) ConnType() string { return psycopgConnType } + +// IsAsync returns true; only the async psycopg flavor exists. +func (p *psycopgBase) IsAsync() bool { return true } + +// NeedsConversion reports whether a SQL type needs runtime conversion. +func (p *psycopgBase) NeedsConversion(sqlType string) bool { + return asyncpgNeedsConversion(sqlType) +} + +// ConvertsInline mirrors asyncpg: bytea, inet, and cidr convert inline in +// decode code; json and jsonb are handled by registered loaders instead. +func (p *psycopgBase) ConvertsInline(sqlType string) bool { + return asyncpgNeedsConversion(sqlType) +} + +// SupportsCommand returns if the driver supports the command. +func (p *psycopgBase) SupportsCommand(cmd string) bool { + switch cmd { + case metadata.CmdExec, + metadata.CmdExecResult, + metadata.CmdExecRows, + metadata.CmdOne, + metadata.CmdMany, + metadata.CmdCopyFrom: + return true + default: + return false + } +} + +// TypeCheckingHook returns the ConnectionLike type alias. TupleRow is the +// default row factory's type, so the alias also documents that generated code +// expects tuple rows, and pyright rejects e.g. dict_row connections. +func (p *psycopgBase) TypeCheckingHook() []string { + return []string{ + fmt.Sprintf("type ConnectionLike = psycopg.AsyncConnection[%s]", psycopgResultType), + } +} + +// PsycopgJSONTypesReturned collects the distinct json/jsonb type names a +// module's queries return, which decide the loader registrations. +func PsycopgJSONTypesReturned(queries []model.Query) []string { + seen := make(map[string]struct{}) + for _, query := range queries { + collect := func(typ model.PyType) { + switch typ.SQLType { + case "json", "pg_catalog.json": + seen["json"] = struct{}{} + case "jsonb": + seen["jsonb"] = struct{}{} + } + } + if query.Returns.IsStruct() { + for _, col := range query.Returns.Table.Columns { + if col.Embed != nil { + for _, embedColumn := range col.Embed.Columns { + collect(embedColumn.Type) + } + + continue + } + collect(col.Type) + } + + continue + } + collect(query.Returns.Type) + } + names := make([]string, 0, len(seen)) + for name := range seen { + names = append(names, name) + } + slices.Sort(names) + + return names +} + +// WriteConversionSetup registers a raw-text loader for returned json/jsonb +// columns, keeping their str wire type in line with the other drivers - +// psycopg would otherwise parse them into Python objects that cannot be +// passed back as parameters. Like sqlite converter registration, the adapters +// map is process-global, and each module registers only what it returns. +func (p *psycopgBase) WriteConversionSetup(body *writer.CodeWriter, _ *config.Config, queries []model.Query) bool { + names := PsycopgJSONTypesReturned(queries) + for _, name := range names { + body.WriteLine(fmt.Sprintf(`psycopg.adapters.register_loader("%s", psycopg.types.string.TextLoader)`, name)) + } + + return len(names) != 0 +} + +// WriteQueryResultsClass writes the async QueryResults class for psycopg +// :many queries. Note the default cursor buffers the full result set client +// side on execute; iteration decodes row by row but does not stream from the +// server. +func (p *psycopgBase) WriteQueryResultsClass(body *writer.CodeWriter) string { + body.QueryResults.WriteQueryResultsClassHeaderNamedParams(psycopgConnType, []string{ + fmt.Sprintf("self._cursor: psycopg.AsyncCursor[%s] | None = None", psycopgResultType), + fmt.Sprintf("self._iterator: collections.abc.AsyncIterator[%s] | None = None", psycopgResultType), + }, psycopgResultType, true) + body.QueryResults.WriteQueryResultsAwaitFunction([]string{ + "result = await (await self._conn.execute(self._sql, self._params)).fetchall()", + decodeRowsExpr, + }) + writeAsyncNextMethod(body, "a psycopg cursor", "self._cursor = await self._conn.execute(self._sql, self._params)") + + return queryResultsClassName +} + +// psycopgParamValue converts a parameter expression for the binding dict. +// Beyond the shared override conversion, unconverted sequence parameters are +// copied into a list: psycopg only dumps lists as arrays (a tuple becomes a +// composite record), while the annotation permits any sequence like asyncpg. +func psycopgParamValue(expr string, typ model.PyType) string { + converted := convertParamExpr(expr, typ) + if !typ.IsList || converted != expr { + return converted + } + if typ.IsNullable { + return fmt.Sprintf("list(%s) if %s is not None else None", expr, expr) + } + + return "list(" + expr + ")" +} + +// psycopgParamEntries returns the named-binding dict entries for a query's +// parameters, keyed by sqlc parameter number to match the %(pN)s rewrite. +func psycopgParamEntries(query model.Query) []string { + entries := make([]string, 0, len(query.Params)) + appendEntry := func(number int32, expr string, typ model.PyType) { + entries = append(entries, fmt.Sprintf(`"p%d": %s`, number, psycopgParamValue(expr, typ))) + } + for _, param := range query.Params { + if param.IsEmpty() { + continue + } + if param.EmitTable && param.Table != nil { + for _, col := range param.Table.Columns { + appendEntry(col.Number, fmt.Sprintf("%s.%s", param.Name, col.Name), col.Type) + } + + continue + } + appendEntry(param.Number, param.Name, param.Type) + } + + return entries +} + +// writePsycopgCall writes head+leadArgs+dict+")" on one line, hoisting a +// too-long params dict into a local sql_params variable first; overlong +// statements wrap through WriteWrappedCall like every other driver. Only +// :many modules define QueryResultsArgsType, so only the :many hoist is +// annotated with it - there the declared type must match the QueryResults +// parameter exactly (dict is invariant), while conn.execute() accepts any +// string mapping. +func writePsycopgCall(body *writer.CodeWriter, indent int, query model.Query, head string, leadArgs []string) { + entries := psycopgParamEntries(query) + if len(entries) == 0 { + body.WriteWrappedCall(indent, head, leadArgs, ")") + + return + } + + dict := "{" + strings.Join(entries, ", ") + "}" + stmt := head + strings.Join(append(slices.Clone(leadArgs), dict), ", ") + ")" + if body.FitsLine(indent, stmt) { + body.WriteIndentedLine(indent, stmt) + + return + } + + hoist := "sql_params = {" + if query.Cmd == metadata.CmdMany { + hoist = "sql_params: dict[str, QueryResultsArgsType] = {" + } + body.WriteIndentedLine(indent, hoist) + for _, entry := range entries { + body.WriteIndentedLine(indent+1, entry+",") + } + body.WriteIndentedLine(indent, "}") + body.WriteWrappedCall(indent, head, append(slices.Clone(leadArgs), "sql_params"), ")") +} + +// writePsycopgOneCall writes the :one fetch statement. Its tail closes two +// parentheses, which WriteWrappedCall's exploded form cannot express in a +// ruff-stable way, so the overlong case emits ruff format's nested-await +// layout instead. +func writePsycopgOneCall(body *writer.CodeWriter, indent int, query model.Query, conn string) { + entries := psycopgParamEntries(query) + head := fmt.Sprintf("row = await (await %s.execute(", conn) + args := []string{query.ConstantName} + if len(entries) != 0 { + dict := "{" + strings.Join(entries, ", ") + "}" + stmt := head + query.ConstantName + ", " + dict + ")).fetchone()" + if body.FitsLine(indent, stmt) { + body.WriteIndentedLine(indent, stmt) + + return + } + body.WriteIndentedLine(indent, "sql_params = {") + for _, entry := range entries { + body.WriteIndentedLine(indent+1, entry+",") + } + body.WriteIndentedLine(indent, "}") + args = append(args, "sql_params") + } + + stmt := head + strings.Join(args, ", ") + ")).fetchone()" + if body.FitsLine(indent, stmt) { + body.WriteIndentedLine(indent, stmt) + + return + } + body.WriteIndentedLine(indent, "row = await (") + body.WriteIndentedLine(indent+1, fmt.Sprintf("await %s.execute(", conn)) + for _, arg := range args { + body.WriteIndentedLine(indent+2, arg+",") + } + body.WriteIndentedLine(indent+1, ")") + body.WriteIndentedLine(indent, ").fetchone()") +} + +func (p *psycopgBase) WriteQueryFunc(body *writer.CodeWriter, config *config.Config, query model.Query, indent int) { + cursorType := fmt.Sprintf("psycopg.AsyncCursor[%s]", psycopgResultType) + var annotation, docRetType string + switch query.Cmd { + case metadata.CmdExec: + annotation, docRetType = query.Returns.Type.Print(), "" + case metadata.CmdExecResult: + annotation, docRetType = cursorType, cursorType + case metadata.CmdExecRows, metadata.CmdCopyFrom: + annotation, docRetType = query.Returns.Type.Print(), query.Returns.Type.Type + case metadata.CmdOne: + annotation, docRetType = query.Returns.Type.PrintOptional(), query.Returns.Type.Type + case metadata.CmdMany: + annotation, docRetType = "QueryResults["+query.Returns.Type.Print()+"]", query.Returns.Type.Print() + } + + conn := writeFuncSignature(body, p, config, indent, query, annotation) + + indent++ + writeQueryDocstring(body, p, config, query, indent, docRetType) + + execHead := fmt.Sprintf("await %s.execute(", conn) + constArg := []string{query.ConstantName} + switch query.Cmd { + case metadata.CmdExec: + writePsycopgCall(body, indent, query, execHead, constArg) + + case metadata.CmdExecResult: + writePsycopgCall(body, indent, query, "return "+execHead, constArg) + + case metadata.CmdExecRows: + writePsycopgCall(body, indent, query, "cur = "+execHead, constArg) + body.WriteIndentedLine(indent, "return cur.rowcount") + + case metadata.CmdCopyFrom: + p.writeCopyFromBody(body, query, conn, indent) + + case metadata.CmdOne: + writePsycopgOneCall(body, indent, query, conn) + body.WriteIndentedLine(indent, "if row is None:") + body.WriteIndentedLine(indent+1, "return None") + + if query.Returns.IsStruct() { + p.rows.WriteStructReturn(body, indent, query.Returns) + } else { + p.rows.WriteScalarReturn(body, indent, query.Returns) + } + + case metadata.CmdMany: + decodeHook := p.rows.WriteDecodeHook(body, indent, query, psycopgResultType) + writePsycopgCall( + body, + indent, + query, + "return QueryResults(", + []string{conn, query.ConstantName, decodeHook}, + ) + } +} + +// writeCopyFromBody writes the body for a psycopg :copyfrom command: rows +// stream through cursor.copy(), and the cursor reports the inserted count. +func (p *psycopgBase) writeCopyFromBody(body *writer.CodeWriter, query model.Query, conn string, indent int) { + columns := query.Params[0].Table.Columns + rowParts := make([]string, 0, len(columns)) + columnParts := make([]string, 0, len(columns)) + for _, col := range columns { + // Overridden columns convert back to their DefaultType here too: + // copy() receives the raw row values, so this is the only place the + // conversion can happen for :copyfrom. + rowParts = append(rowParts, psycopgParamValue("param."+col.Name, col.Type)) + columnParts = append(columnParts, quoteSQLIdent(col.DBName)) + } + + table := quoteSQLIdent(query.Table.Name) + if query.Table.Schema != "" { + table = quoteSQLIdent(query.Table.Schema) + "." + table + } + copyStmt := fmt.Sprintf("COPY %s (%s) FROM STDIN", table, strings.Join(columnParts, ", ")) + + rowTuple := "(" + strings.Join(rowParts, ", ") + ")" + if len(rowParts) == 1 { + // A one-element tuple needs the trailing comma, otherwise the + // parentheses are just grouping and the row is a bare value. + rowTuple = "(" + rowParts[0] + ",)" + } + + copyIndent := indent + 1 + loopIndent := copyIndent + 1 + rowIndent := loopIndent + 1 + body.WriteIndentedLine(indent, fmt.Sprintf("async with %s.cursor() as cur:", conn)) + copyCall := fmt.Sprintf("async with cur.copy(%s) as copy:", writer.PyQuote(copyStmt)) + if body.FitsLine(copyIndent, copyCall) { + body.WriteIndentedLine(copyIndent, copyCall) + } else { + // Matches ruff format's layout for an overlong single-string call: + // the string moves to its own line WITHOUT a magic trailing comma. + body.WriteIndentedLine(copyIndent, "async with cur.copy(") + body.WriteIndentedLine(loopIndent, writer.PyQuote(copyStmt)) + body.WriteIndentedLine(copyIndent, ") as copy:") + } + body.WriteIndentedLine(loopIndent, "for param in "+query.Params[0].Name+":") + writeRow := "await copy.write_row(" + rowTuple + ")" + switch { + case body.FitsLine(rowIndent, writeRow): + body.WriteIndentedLine(rowIndent, writeRow) + case len(rowParts) == 1 && body.FitsLine(rowIndent+1, rowTuple): + // ruff format keeps a fitting one-element tuple on a single line - + // its required trailing comma is not a magic one. + body.WriteIndentedLine(rowIndent, "await copy.write_row(") + body.WriteIndentedLine(rowIndent+1, rowTuple) + body.WriteIndentedLine(rowIndent, ")") + default: + // ruff format's stable layout: the tuple opens on its own line inside + // the call and the magic trailing comma keeps it exploded. + body.WriteIndentedLine(rowIndent, "await copy.write_row(") + body.WriteIndentedLine(rowIndent+1, "(") + for _, part := range rowParts { + body.WriteIndentedLine(rowIndent+2, part+",") + } + body.WriteIndentedLine(rowIndent+1, ")") + body.WriteIndentedLine(rowIndent, ")") + } + body.WriteIndentedLine(copyIndent, "return cur.rowcount") +} + +// quoteSQLIdent double-quotes a SQL identifier for the generated COPY +// statement, escaping embedded quotes by doubling them. +func quoteSQLIdent(name string) string { + return `"` + strings.ReplaceAll(name, `"`, `""`) + `"` +} diff --git a/internal/driver/psycopg_test.go b/internal/driver/psycopg_test.go new file mode 100644 index 00000000..fd66e2e1 --- /dev/null +++ b/internal/driver/psycopg_test.go @@ -0,0 +1,834 @@ +package driver_test + +import ( + "slices" + "strings" + "testing" + + "github.com/rayakame/sqlc-gen-better-python/internal/config" + "github.com/rayakame/sqlc-gen-better-python/internal/driver" + "github.com/rayakame/sqlc-gen-better-python/internal/model" + "github.com/rayakame/sqlc-gen-better-python/internal/utils" + "github.com/rayakame/sqlc-gen-better-python/internal/writer" + "github.com/sqlc-dev/plugin-sdk-go/metadata" + "github.com/sqlc-dev/plugin-sdk-go/plugin" +) + +func psycopgTestConfig() *config.Config { + return &config.Config{ + SqlDriver: config.SQLDriverPsycopgAsync, + EmitDocstrings: config.DocstringConventionNone, + EmitDocstringsSQL: utils.ToPtr(true), + IndentChar: " ", + CharsPerIndentLevel: 4, + OmitKwargsLimit: 8, + } +} + +func newPsycopg(t *testing.T) driver.Driver { + t.Helper() + d, err := driver.New(psycopgTestConfig()) + if err != nil { + t.Fatalf("driver.New() error = %v", err) + } + + return d +} + +func psycopgAuthorReturn() model.QueryValue { + return model.QueryValue{ + Table: &model.Table{ + Name: "Author", + Columns: []model.Column{ + {Name: "id", Type: model.PyType{Type: "int", SQLType: "bigint"}}, + {Name: "name", Type: model.PyType{Type: "str", SQLType: "text"}}, + }, + }, + Type: model.PyType{Type: "models.Author"}, + } +} + +func TestPsycopgDriverMetadata(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + if got := d.Name(); got != "psycopg" { + t.Errorf("Name() = %q, want %q", got, "psycopg") + } + if got := d.ConnType(); got != "ConnectionLike" { + t.Errorf("ConnType() = %q, want %q", got, "ConnectionLike") + } + if !d.IsAsync() { + t.Error("IsAsync() = false, want true") + } + wantHook := []string{"type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow]"} + if got := d.TypeCheckingHook(); !slices.Equal(got, wantHook) { + t.Errorf("TypeCheckingHook() = %q, want %q", got, wantHook) + } +} + +func TestPsycopgConversions(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + // Identical to asyncpg: bytea/inet/cidr convert inline, json does not - + // registered loaders keep it a str before decode code ever sees it. + for sqlType, want := range map[string]bool{ + "bytea": true, "inet": true, "cidr": true, + "json": false, "jsonb": false, "text": false, + } { + if got := d.NeedsConversion(sqlType); got != want { + t.Errorf("NeedsConversion(%q) = %v, want %v", sqlType, got, want) + } + if got := d.ConvertsInline(sqlType); got != want { + t.Errorf("ConvertsInline(%q) = %v, want %v", sqlType, got, want) + } + } +} + +func TestPsycopgSupportsCommand(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + for cmd, want := range map[string]bool{ + metadata.CmdExec: true, + metadata.CmdExecResult: true, + metadata.CmdExecRows: true, + metadata.CmdOne: true, + metadata.CmdMany: true, + metadata.CmdCopyFrom: true, + metadata.CmdExecLastId: false, + ":batchexec": false, + } { + if got := d.SupportsCommand(cmd); got != want { + t.Errorf("SupportsCommand(%q) = %v, want %v", cmd, got, want) + } + } +} + +func TestPsycopgJSONTypesReturned(t *testing.T) { + t.Parallel() + jsonCol := model.Column{Name: "meta", Type: model.PyType{Type: "str", SQLType: "json"}} + jsonbType := model.PyType{Type: "str", SQLType: "jsonb"} + cases := []struct { + name string + queries []model.Query + want []string + }{ + { + name: "no json returns", + queries: []model.Query{{Returns: model.QueryValue{Type: model.PyType{Type: "int", SQLType: "bigint"}}}}, + want: []string{}, + }, + { + name: "scalar jsonb return", + queries: []model.Query{{Returns: model.QueryValue{Type: jsonbType}}}, + want: []string{"jsonb"}, + }, + { + name: "struct with json and pg_catalog.json plus embed", + queries: []model.Query{{ + Returns: model.QueryValue{ + Table: &model.Table{Name: "Row", Columns: []model.Column{ + jsonCol, + {Name: "legacy", Type: model.PyType{Type: "str", SQLType: "pg_catalog.json"}}, + {Name: "author", Embed: &model.Embed{Columns: []model.Column{ + {Name: "prefs", Type: jsonbType}, + }}}, + }}, + Type: model.PyType{Type: "models.Row"}, + }, + }}, + want: []string{"json", "jsonb"}, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + got := driver.PsycopgJSONTypesReturned(tc.queries) + if len(got) == 0 && len(tc.want) == 0 { + return + } + if !slices.Equal(got, tc.want) { + t.Errorf("PsycopgJSONTypesReturned() = %q, want %q", got, tc.want) + } + }) + } +} + +func TestPsycopgWriteConversionSetup(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + conf := psycopgTestConfig() + + w := writer.NewCodeWriter(conf) + queries := []model.Query{{Returns: model.QueryValue{Type: model.PyType{Type: "str", SQLType: "jsonb"}}}} + if !d.WriteConversionSetup(w, conf, queries) { + t.Fatal("WriteConversionSetup() = false, want true for a jsonb return") + } + want := "psycopg.adapters.register_loader(\"jsonb\", psycopg.types.string.TextLoader)\n" + if got := w.String(); got != want { + t.Errorf("WriteConversionSetup() wrote %q, want %q", got, want) + } + + w = writer.NewCodeWriter(conf) + queries = []model.Query{{Returns: model.QueryValue{Type: model.PyType{Type: "int", SQLType: "bigint"}}}} + if d.WriteConversionSetup(w, conf, queries) { + t.Error("WriteConversionSetup() = true, want false without json returns") + } + if got := w.String(); got != "" { + t.Errorf("WriteConversionSetup() wrote %q, want nothing", got) + } +} + +func TestPsycopgWriteQueryResultsClass(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + w := writer.NewCodeWriter(psycopgTestConfig()) + if got := d.WriteQueryResultsClass(w); got != "QueryResults" { + t.Errorf("WriteQueryResultsClass() = %q, want %q", got, "QueryResults") + } + want := strings.Join([]string{ + "class QueryResults[T]:", + ` __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql")`, + "", + " def __init__(", + " self,", + " conn: ConnectionLike,", + " sql: typing.LiteralString,", + " decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T],", + " params: dict[str, QueryResultsArgsType] | None = None,", + " ) -> None:", + " self._conn = conn", + " self._sql: typing.LiteralString = sql", + " self._decode_hook = decode_hook", + " self._params = params", + " self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None", + " self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None", + "", + " def __aiter__(self) -> QueryResults[T]:", + " return self", + "", + " def __await__(", + " self,", + " ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]:", + " async def _wrapper() -> collections.abc.Sequence[T]:", + " result = await (await self._conn.execute(self._sql, self._params)).fetchall()", + " return [self._decode_hook(row) for row in result]", + "", + " return _wrapper().__await__()", + "", + " async def __anext__(self) -> T:", + " if self._cursor is None or self._iterator is None:", + " self._cursor = await self._conn.execute(self._sql, self._params)", + " self._iterator = self._cursor.__aiter__()", + " try:", + " record = await self._iterator.__anext__()", + " except StopAsyncIteration:", + " self._cursor = None", + " self._iterator = None", + " raise", + " return self._decode_hook(record)", + }, "\n") + "\n" + if got := w.String(); got != want { + t.Errorf("WriteQueryResultsClass() wrote %q, want %q", got, want) + } +} + +func TestPsycopgWriteQueryFunc(t *testing.T) { + t.Parallel() + longName := strings.Repeat("p", 340) + cases := []struct { + name string + query model.Query + want string + }{ + { + name: "exec without params", + query: model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "DELETE_ALL", + FuncName: "delete_all", + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def delete_all(conn: ConnectionLike) -> None:", + " await conn.execute(DELETE_ALL)", + "", + }, "\n"), + }, + { + name: "exec with params binds by number", + query: model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "DELETE_AUTHOR", + FuncName: "delete_author", + Params: []model.QueryValue{ + {Name: "author_id", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def delete_author(conn: ConnectionLike, author_id: int) -> None:", + ` await conn.execute(DELETE_AUTHOR, {"p1": author_id})`, + "", + }, "\n"), + }, + { + name: "exec with overridden param converts before binding", + query: model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "SET_CREATED_AT", + FuncName: "set_created_at", + Params: []model.QueryValue{ + {Name: "created_at", Type: model.PyType{ + Type: "float", + SQLType: "timestamp", + IsOverride: true, + DefaultType: "datetime.datetime", + }, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def set_created_at(conn: ConnectionLike, created_at: float) -> None:", + ` await conn.execute(SET_CREATED_AT, {"p1": datetime.datetime(created_at)})`, + "", + }, "\n"), + }, + { + name: "exec long params hoisted into sql_params", + query: model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "HOIST", + FuncName: "hoist", + Params: []model.QueryValue{ + {Name: longName, Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def hoist(", + " conn: ConnectionLike,", + " " + longName + ": int,", + ") -> None:", + " sql_params = {", + ` "p1": ` + longName + ",", + " }", + " await conn.execute(HOIST, sql_params)", + "", + }, "\n"), + }, + { + name: "exec array param copies into a list", + query: model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "DELETE_MANY", + FuncName: "delete_many", + Params: []model.QueryValue{ + {Name: "ids", Type: model.PyType{Type: "int", SQLType: "bigint", IsList: true}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def delete_many(conn: ConnectionLike, ids: collections.abc.Sequence[int]) -> None:", + ` await conn.execute(DELETE_MANY, {"p1": list(ids)})`, + "", + }, "\n"), + }, + { + name: "exec nullable array param guards the list copy", + query: model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "SET_TAGS", + FuncName: "set_tags", + Params: []model.QueryValue{ + {Name: "tags", Type: model.PyType{Type: "str", SQLType: "text", IsList: true, IsNullable: true}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def set_tags(conn: ConnectionLike, tags: collections.abc.Sequence[str] | None) -> None:", + ` await conn.execute(SET_TAGS, {"p1": list(tags) if tags is not None else None})`, + "", + }, "\n"), + }, + { + name: "exec overridden array param converts element-wise without a list copy", + query: model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "SET_PRICES", + FuncName: "set_prices", + Params: []model.QueryValue{ + {Name: "prices", Type: model.PyType{ + Type: "float", + SQLType: "numeric", + IsList: true, + IsOverride: true, + DefaultType: "decimal.Decimal", + }, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def set_prices(conn: ConnectionLike, prices: collections.abc.Sequence[float]) -> None:", + ` await conn.execute(SET_PRICES, {"p1": [decimal.Decimal(v) for v in prices]})`, + "", + }, "\n"), + }, + { + name: "many long params hoist keeps the args-type annotation", + query: model.Query{ + Cmd: metadata.CmdMany, + ConstantName: "LIST_LONG", + FuncName: "list_long", + Params: []model.QueryValue{ + {Name: longName, Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "int", SQLType: "bigint"}}, + }, + want: strings.Join([]string{ + "def list_long(", + " conn: ConnectionLike,", + " " + longName + ": int,", + ") -> QueryResults[int]:", + " sql_params: dict[str, QueryResultsArgsType] = {", + ` "p1": ` + longName + ",", + " }", + " return QueryResults(conn, LIST_LONG, operator.itemgetter(0), sql_params)", + "", + }, "\n"), + }, + { + name: "execresult returns the cursor", + query: model.Query{ + Cmd: metadata.CmdExecResult, + ConstantName: "UPDATE_ROWS", + FuncName: "update_rows", + Params: []model.QueryValue{ + {Name: "id_", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + }, + want: strings.Join([]string{ + "async def update_rows(conn: ConnectionLike, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]:", + ` return await conn.execute(UPDATE_ROWS, {"p1": id_})`, + "", + }, "\n"), + }, + { + name: "execrows returns rowcount", + query: model.Query{ + Cmd: metadata.CmdExecRows, + ConstantName: "UPDATE_ROWS", + FuncName: "update_rows", + Params: []model.QueryValue{ + {Name: "id_", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + }, + want: strings.Join([]string{ + "async def update_rows(conn: ConnectionLike, id_: int) -> int:", + ` cur = await conn.execute(UPDATE_ROWS, {"p1": id_})`, + " return cur.rowcount", + "", + }, "\n"), + }, + { + name: "one struct return", + query: model.Query{ + Cmd: metadata.CmdOne, + ConstantName: "GET_AUTHOR", + FuncName: "get_author", + Params: []model.QueryValue{ + {Name: "id_", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + Returns: psycopgAuthorReturn(), + }, + want: strings.Join([]string{ + "async def get_author(conn: ConnectionLike, id_: int) -> models.Author | None:", + ` row = await (await conn.execute(GET_AUTHOR, {"p1": id_})).fetchone()`, + " if row is None:", + " return None", + " return models.Author(id=row[0], name=row[1])", + "", + }, "\n"), + }, + { + name: "one scalar return", + query: model.Query{ + Cmd: metadata.CmdOne, + ConstantName: "COUNT_AUTHORS", + FuncName: "count_authors", + Returns: model.QueryValue{Type: model.PyType{Type: "int", SQLType: "bigint"}}, + }, + want: strings.Join([]string{ + "async def count_authors(conn: ConnectionLike) -> int | None:", + " row = await (await conn.execute(COUNT_AUTHORS)).fetchone()", + " if row is None:", + " return None", + " return row[0]", + "", + }, "\n"), + }, + { + name: "one long params hoist into sql_params", + query: model.Query{ + Cmd: metadata.CmdOne, + ConstantName: "GET_LONG", + FuncName: "get_long", + Params: []model.QueryValue{ + {Name: longName, Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "int", SQLType: "bigint"}}, + }, + want: strings.Join([]string{ + "async def get_long(", + " conn: ConnectionLike,", + " " + longName + ": int,", + ") -> int | None:", + " sql_params = {", + ` "p1": ` + longName + ",", + " }", + " row = await (await conn.execute(GET_LONG, sql_params)).fetchone()", + " if row is None:", + " return None", + " return row[0]", + "", + }, "\n"), + }, + { + name: "one long constant explodes into the nested await layout", + query: model.Query{ + Cmd: metadata.CmdOne, + ConstantName: longName, + FuncName: "get_named", + Returns: model.QueryValue{Type: model.PyType{Type: "int", SQLType: "bigint"}}, + }, + want: strings.Join([]string{ + "async def get_named(conn: ConnectionLike) -> int | None:", + " row = await (", + " await conn.execute(", + " " + longName + ",", + " )", + " ).fetchone()", + " if row is None:", + " return None", + " return row[0]", + "", + }, "\n"), + }, + { + name: "many struct return with decode hook", + query: model.Query{ + Cmd: metadata.CmdMany, + ConstantName: "LIST_AUTHORS", + FuncName: "list_authors", + Params: []model.QueryValue{ + {Name: "name", Type: model.PyType{Type: "str", SQLType: "text"}, Number: 1}, + }, + Returns: psycopgAuthorReturn(), + }, + want: strings.Join([]string{ + "def list_authors(conn: ConnectionLike, name: str) -> QueryResults[models.Author]:", + " def _decode_hook(row: psycopg.rows.TupleRow) -> models.Author:", + " return models.Author(id=row[0], name=row[1])", + "", + ` return QueryResults(conn, LIST_AUTHORS, _decode_hook, {"p1": name})`, + "", + }, "\n"), + }, + { + name: "many scalar without params uses itemgetter", + query: model.Query{ + Cmd: metadata.CmdMany, + ConstantName: "LIST_IDS", + FuncName: "list_ids", + Returns: model.QueryValue{Type: model.PyType{Type: "int", SQLType: "bigint"}}, + }, + want: strings.Join([]string{ + "def list_ids(conn: ConnectionLike) -> QueryResults[int]:", + " return QueryResults(conn, LIST_IDS, operator.itemgetter(0))", + "", + }, "\n"), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + conf := psycopgTestConfig() + body := writer.NewCodeWriter(conf) + d.WriteQueryFunc(body, conf, tc.query, 0) + if got := body.String(); got != tc.want { + t.Errorf("WriteQueryFunc() = %q, want %q", got, tc.want) + } + }) + } +} + +func TestPsycopgWriteQueryFuncCopyFrom(t *testing.T) { + t.Parallel() + longName := strings.Repeat("c", 340) + // Long enough that write_row((...)) overflows, short enough that the + // one-element tuple still fits on its own line. + bandName := strings.Repeat("d", 280) + cases := []struct { + name string + query model.Query + want string + }{ + { + name: "copyfrom streams rows and returns rowcount", + query: model.Query{ + Cmd: metadata.CmdCopyFrom, + ConstantName: "COPY_AUTHORS", + FuncName: "copy_authors", + Table: &plugin.Identifier{Name: "authors"}, + Params: []model.QueryValue{{ + EmitTable: true, + Name: "params", + Type: model.PyType{Type: "CopyAuthorsParams", IsList: true}, + Table: &model.Table{ + Name: "CopyAuthorsParams", + Columns: []model.Column{ + {Name: "id_", DBName: "id", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + {Name: "name", DBName: "name", Type: model.PyType{Type: "str", SQLType: "text"}, Number: 2}, + { + Name: "tags", + DBName: "tags", + Type: model.PyType{Type: "str", SQLType: "text", IsList: true}, + Number: 3, + }, + }, + }, + }}, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + }, + want: strings.Join([]string{ + "async def copy_authors(conn: ConnectionLike, params: collections.abc.Sequence[CopyAuthorsParams]) -> int:", + " async with conn.cursor() as cur:", + ` async with cur.copy('COPY "authors" ("id", "name", "tags") FROM STDIN') as copy:`, + " for param in params:", + " await copy.write_row((param.id_, param.name, list(param.tags)))", + " return cur.rowcount", + "", + }, "\n"), + }, + { + name: "copyfrom long copy statement explodes", + query: model.Query{ + Cmd: metadata.CmdCopyFrom, + ConstantName: "COPY_BIG", + FuncName: "copy_big", + Table: &plugin.Identifier{Name: "big"}, + Params: []model.QueryValue{{ + EmitTable: true, + Name: "params", + Type: model.PyType{Type: "CopyBigParams", IsList: true}, + Table: &model.Table{ + Name: "CopyBigParams", + Columns: []model.Column{ + {Name: "d", DBName: longName, Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + }, + }}, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + }, + want: strings.Join([]string{ + "async def copy_big(conn: ConnectionLike, params: collections.abc.Sequence[CopyBigParams]) -> int:", + " async with conn.cursor() as cur:", + " async with cur.copy(", + ` 'COPY "big" ("` + longName + `") FROM STDIN'`, + " ) as copy:", + " for param in params:", + " await copy.write_row((param.d,))", + " return cur.rowcount", + "", + }, "\n"), + }, + { + name: "copyfrom single overridden column in a schema", + query: model.Query{ + Cmd: metadata.CmdCopyFrom, + ConstantName: "COPY_PRICES", + FuncName: "copy_prices", + Table: &plugin.Identifier{Schema: "billing", Name: "prices"}, + Params: []model.QueryValue{{ + EmitTable: true, + Name: "params", + Type: model.PyType{Type: "CopyPricesParams", IsList: true}, + Table: &model.Table{ + Name: "CopyPricesParams", + Columns: []model.Column{ + {Name: "amount", DBName: "amount", Type: model.PyType{ + Type: "float", + SQLType: "numeric", + IsOverride: true, + DefaultType: "decimal.Decimal", + }, Number: 1}, + }, + }, + }}, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + }, + want: strings.Join([]string{ + "async def copy_prices(conn: ConnectionLike, params: collections.abc.Sequence[CopyPricesParams]) -> int:", + " async with conn.cursor() as cur:", + ` async with cur.copy('COPY "billing"."prices" ("amount") FROM STDIN') as copy:`, + " for param in params:", + " await copy.write_row((decimal.Decimal(param.amount),))", + " return cur.rowcount", + "", + }, "\n"), + }, + { + name: "copyfrom long row tuple explodes", + query: model.Query{ + Cmd: metadata.CmdCopyFrom, + ConstantName: "COPY_WIDE", + FuncName: "copy_wide", + Table: &plugin.Identifier{Name: "wide"}, + Params: []model.QueryValue{{ + EmitTable: true, + Name: "params", + Type: model.PyType{Type: "CopyWideParams", IsList: true}, + Table: &model.Table{ + Name: "CopyWideParams", + Columns: []model.Column{ + {Name: longName, DBName: "a", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + {Name: "b", DBName: "b", Type: model.PyType{Type: "str", SQLType: "text"}, Number: 2}, + }, + }, + }}, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + }, + want: strings.Join([]string{ + "async def copy_wide(conn: ConnectionLike, params: collections.abc.Sequence[CopyWideParams]) -> int:", + " async with conn.cursor() as cur:", + ` async with cur.copy('COPY "wide" ("a", "b") FROM STDIN') as copy:`, + " for param in params:", + " await copy.write_row(", + " (", + " param." + longName + ",", + " param.b,", + " )", + " )", + " return cur.rowcount", + "", + }, "\n"), + }, + { + name: "copyfrom long single-column row keeps the one-line tuple", + query: model.Query{ + Cmd: metadata.CmdCopyFrom, + ConstantName: "COPY_ONE", + FuncName: "copy_one", + Table: &plugin.Identifier{Name: "one"}, + Params: []model.QueryValue{{ + EmitTable: true, + Name: "params", + Type: model.PyType{Type: "CopyOneParams", IsList: true}, + Table: &model.Table{ + Name: "CopyOneParams", + Columns: []model.Column{ + {Name: bandName, DBName: "a", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + }, + }}, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + }, + want: strings.Join([]string{ + "async def copy_one(conn: ConnectionLike, params: collections.abc.Sequence[CopyOneParams]) -> int:", + " async with conn.cursor() as cur:", + ` async with cur.copy('COPY "one" ("a") FROM STDIN') as copy:`, + " for param in params:", + " await copy.write_row(", + " (param." + bandName + ",)", + " )", + " return cur.rowcount", + "", + }, "\n"), + }, + { + name: "copyfrom overlong single-column row explodes the tuple too", + query: model.Query{ + Cmd: metadata.CmdCopyFrom, + ConstantName: "COPY_HUGE", + FuncName: "copy_huge", + Table: &plugin.Identifier{Name: "huge"}, + Params: []model.QueryValue{{ + EmitTable: true, + Name: "params", + Type: model.PyType{Type: "CopyHugeParams", IsList: true}, + Table: &model.Table{ + Name: "CopyHugeParams", + Columns: []model.Column{ + {Name: longName, DBName: "a", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 1}, + }, + }, + }}, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + }, + want: strings.Join([]string{ + "async def copy_huge(conn: ConnectionLike, params: collections.abc.Sequence[CopyHugeParams]) -> int:", + " async with conn.cursor() as cur:", + ` async with cur.copy('COPY "huge" ("a") FROM STDIN') as copy:`, + " for param in params:", + " await copy.write_row(", + " (", + " param." + longName + ",", + " )", + " )", + " return cur.rowcount", + "", + }, "\n"), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + conf := psycopgTestConfig() + body := writer.NewCodeWriter(conf) + d.WriteQueryFunc(body, conf, tc.query, 0) + if got := body.String(); got != tc.want { + t.Errorf("WriteQueryFunc() = %q, want %q", got, tc.want) + } + }) + } +} + +func TestPsycopgWriteQueryFuncBundledParams(t *testing.T) { + t.Parallel() + d := newPsycopg(t) + conf := psycopgTestConfig() + body := writer.NewCodeWriter(conf) + // A query_parameter_limit bundle: fields bind via their sqlc numbers. + query := model.Query{ + Cmd: metadata.CmdExec, + ConstantName: "UPDATE_AUTHOR", + FuncName: "update_author", + Params: []model.QueryValue{ + { + EmitTable: true, + Name: "params", + Type: model.PyType{Type: "UpdateAuthorParams"}, + Table: &model.Table{ + Name: "UpdateAuthorParams", + Columns: []model.Column{ + {Name: "name", DBName: "name", Type: model.PyType{Type: "str", SQLType: "text"}, Number: 1}, + {Name: "id_", DBName: "id", Type: model.PyType{Type: "int", SQLType: "bigint"}, Number: 2}, + }, + }, + }, + }, + Returns: model.QueryValue{Type: model.PyType{Type: "None"}}, + } + d.WriteQueryFunc(body, conf, query, 0) + want := strings.Join([]string{ + "async def update_author(conn: ConnectionLike, params: UpdateAuthorParams) -> None:", + ` await conn.execute(UPDATE_AUTHOR, {"p1": params.name, "p2": params.id_})`, + "", + }, "\n") + if got := body.String(); got != want { + t.Errorf("WriteQueryFunc() = %q, want %q", got, want) + } +} diff --git a/internal/driver/sqlite_base.go b/internal/driver/sqlite_base.go index d419937b..b1ba0d88 100644 --- a/internal/driver/sqlite_base.go +++ b/internal/driver/sqlite_base.go @@ -170,7 +170,7 @@ func (sb *sqliteBase) WriteQueryResultsClass(body *writer.CodeWriter) string { body.WriteIndentedLine(3, "raise") body.WriteIndentedLine(2, "return self._decode_hook(record)") - return "QueryResults" + return queryResultsClassName } func (sb *sqliteBase) WriteQueryFunc(body *writer.CodeWriter, config *config.Config, query model.Query, indent int) { diff --git a/internal/model/types.go b/internal/model/types.go index f36ab920..8510eb6b 100644 --- a/internal/model/types.go +++ b/internal/model/types.go @@ -83,6 +83,10 @@ type Column struct { DBName string // The raw database column name Type PyType + // Number is the 1-based sqlc parameter number when this column belongs + // to a bundled Params class; 0 for table model columns. + Number int32 + Embed *Embed } @@ -119,6 +123,10 @@ type QueryValue struct { Table *Table Name string Type PyType + + // Number is the 1-based sqlc parameter number, used by drivers that + // bind by name (psycopg's %(pN)s); 0 for return values. + Number int32 } type Embed struct { diff --git a/internal/render/imports.go b/internal/render/imports.go index 27cd57bf..741159b4 100644 --- a/internal/render/imports.go +++ b/internal/render/imports.go @@ -536,6 +536,26 @@ func (r *ImportResolver) addDriverImports( } } + case config.SQLDriverPsycopgAsync: + // The module is psycopg regardless of the driver option name. + // psycopg.rows.TupleRow appears in the ConnectionLike alias of every + // query module, not only in :many decode hooks. The loader + // registrations run at import time and reference + // psycopg.types.string.TextLoader, forcing psycopg runtime - and then + // psycopg.rows follows, since a TYPE_CHECKING submodule import of a + // runtime-imported parent trips ruff's TC004. + if len(driver.PsycopgJSONTypesReturned(queries)) != 0 { + std["psycopg"] = importSpec{Module: "psycopg"} + std["psycopg.types.string"] = importSpec{Module: "psycopg.types.string"} + std["psycopg.rows"] = importSpec{Module: "psycopg.rows"} + } else { + typeChecking["psycopg"] = importSpec{Module: "psycopg"} + typeChecking["psycopg.rows"] = importSpec{Module: "psycopg.rows"} + } + if hasMany && r.hasSimpleReturn(queries) { + std["operator"] = importSpec{Module: moduleOperator} + } + case config.SQLDriverAioSQLite: // register_adapter/register_converter calls need the module at runtime. if conversions.Any() { diff --git a/internal/render/imports_test.go b/internal/render/imports_test.go index e4ae288f..c7282223 100644 --- a/internal/render/imports_test.go +++ b/internal/render/imports_test.go @@ -527,6 +527,50 @@ func TestQueryImports(t *testing.T) { TypeChecking: []string{"import asyncpg", "import collections.abc"}, }, }, + { + name: "psycopg json return forces runtime module for loaders", + conf: newImportsConfig(config.SQLDriverPsycopgAsync), + queries: []model.Query{ + {Cmd: metadata.CmdOne, Returns: impScalar(model.PyType{SQLType: "jsonb", Type: "str"})}, + }, + want: ImportResult{ + Std: []string{"import psycopg", "import psycopg.rows", "import psycopg.types.string", "import typing"}, + TypeChecking: []string{ + "import collections.abc", + }, + }, + }, + { + name: "psycopg without json returns keeps the module lazy", + conf: newImportsConfig(config.SQLDriverPsycopgAsync), + queries: []model.Query{ + {Cmd: metadata.CmdOne, Returns: impScalar(model.PyType{SQLType: "bigint", Type: "int"})}, + }, + want: ImportResult{ + Std: []string{"import typing"}, + TypeChecking: []string{ + "import collections.abc", + "import psycopg", + "import psycopg.rows", + }, + }, + }, + { + name: "psycopg many simple return imports operator", + conf: newImportsConfig(config.SQLDriverPsycopgAsync), + queries: []model.Query{ + {Cmd: metadata.CmdMany, Returns: impScalar(model.PyType{SQLType: "bigint", Type: "int"})}, + }, + want: ImportResult{ + Std: []string{"import operator", "import typing"}, + TypeChecking: []string{ + "import collections.abc", + "import psycopg", + "import psycopg.rows\n", + argsTypeBase + argsTypeTail, + }, + }, + }, { name: "asyncpg many simple return imports operator", conf: newImportsConfig(config.SQLDriverAsyncpg), diff --git a/internal/render/queries.go b/internal/render/queries.go index 88d3bd49..b5bfc2ef 100644 --- a/internal/render/queries.go +++ b/internal/render/queries.go @@ -4,7 +4,9 @@ import ( "fmt" "strings" + "github.com/rayakame/sqlc-gen-better-python/internal/config" "github.com/rayakame/sqlc-gen-better-python/internal/model" + "github.com/rayakame/sqlc-gen-better-python/internal/types" "github.com/rayakame/sqlc-gen-better-python/internal/utils" "github.com/sqlc-dev/plugin-sdk-go/metadata" "github.com/sqlc-dev/plugin-sdk-go/plugin" @@ -54,9 +56,15 @@ func (r *Renderer) renderQueriesModule(moduleName string, queries []model.Query) all = append(all, className) } + // psycopg's typed execute() takes LiteralString query text, not str, so + // the constants keep their literal type there instead of widening. + constType := types.Str + if r.config.SqlDriver == config.SQLDriverPsycopgAsync { + constType = "typing.LiteralString" + } for _, query := range queries { constantsBody.WriteLine( - fmt.Sprintf(`%s: typing.Final[str] = """-- name: %s %s`, query.ConstantName, query.QueryName, query.Cmd), + fmt.Sprintf(`%s: typing.Final[%s] = """-- name: %s %s`, query.ConstantName, constType, query.QueryName, query.Cmd), ) constantsBody.WriteLine(query.SQL) constantsBody.WriteLine(`"""`) diff --git a/internal/render/render_queries_test.go b/internal/render/render_queries_test.go index e659dcf0..e9bd007e 100644 --- a/internal/render/render_queries_test.go +++ b/internal/render/render_queries_test.go @@ -47,6 +47,40 @@ INSERT INTO test_items (id) VALUES ($1) async def insert_item(conn: ConnectionLike, *, id_: int) -> None: await conn.execute(INSERT_ITEM, id_) +`, + }, + { + name: "psycopg rewrites placeholders and binds by name", + engine: "postgresql", + options: `{"package":"testpkg","sql_driver":"psycopg_async","emit_init_file":false}`, + queries: []*plugin.Query{{ + Name: "InsertItem", + Cmd: metadata.CmdExec, + Text: "INSERT INTO test_items (id) VALUES ($1)", + Filename: "queries.sql", + Params: []*plugin.Parameter{{Number: 1, Column: pgColumn("id", "int4", true)}}, + }}, + want: sqlcFileHeader("queries.sql") + `from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("insert_item",) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +INSERT_ITEM: typing.Final[typing.LiteralString] = """-- name: InsertItem :exec +INSERT INTO test_items (id) VALUES (%(p1)s) +""" + + +async def insert_item(conn: ConnectionLike, *, id_: int) -> None: + await conn.execute(INSERT_ITEM, {"p1": id_}) `, }, { diff --git a/internal/render/renderer.go b/internal/render/renderer.go index 368c10b1..a41628a2 100644 --- a/internal/render/renderer.go +++ b/internal/render/renderer.go @@ -36,7 +36,9 @@ func (r *Renderer) RenderAll(enums []model.Enum, tables []model.Table, queries [ queriesModuleMap := make(map[string][]model.Query) for _, query := range queries { if !r.driver.SupportsCommand(query.Cmd) { - return nil, fmt.Errorf(`unsupported cmd "%s" for driver "%s"`, query.Cmd, r.driver.Name()) + // Name the sql_driver config value, not driver.Name(): for psycopg + // the module name and the option value differ. + return nil, fmt.Errorf(`unsupported cmd "%s" for driver "%s"`, query.Cmd, r.config.SqlDriver) } innerQueries, ok := queriesModuleMap[query.ModuleName] diff --git a/internal/transform/psycopg_sql.go b/internal/transform/psycopg_sql.go new file mode 100644 index 00000000..c82d02ac --- /dev/null +++ b/internal/transform/psycopg_sql.go @@ -0,0 +1,218 @@ +package transform + +import ( + "strings" +) + +// rewritePsycopgSQL converts sqlc's PostgreSQL placeholders into psycopg's +// named pyformat style: $N becomes %(pN)s, and every literal % is doubled, +// since psycopg scans the whole query text for placeholders - including +// string literals and comments - once parameters are passed. String +// literals, quoted identifiers, dollar-quoted strings, and comments are +// tracked so a $N inside them stays text. Callers only rewrite queries that +// actually have parameters; psycopg leaves parameterless queries unscanned. +func rewritePsycopgSQL(sql string) string { + var out strings.Builder + out.Grow(len(sql) + len(sql)/8) + for i := 0; i < len(sql); { + c := sql[i] + switch { + case c == '%': + out.WriteString("%%") + i++ + case c == '$': + // A $ directly after an identifier byte continues that identifier + // (PostgreSQL's ident_cont includes $), so col$2 is a column name, + // never a parameter or dollar-quote start. + if i > 0 && isIdentContByte(sql[i-1]) { + out.WriteByte(c) + i++ + + continue + } + if num, end := scanParamNumber(sql, i); end != -1 { + out.WriteString("%(p" + num + ")s") + i = end + + continue + } + if end := scanDollarQuote(sql, i); end != -1 { + writeDoubled(&out, sql[i:end]) + i = end + + continue + } + out.WriteByte(c) + i++ + case c == '\'': + end := scanStringLiteral(sql, i, isEscapeString(sql, i)) + writeDoubled(&out, sql[i:end]) + i = end + case c == '"': + end := scanQuoted(sql, i, '"') + writeDoubled(&out, sql[i:end]) + i = end + case c == '-' && strings.HasPrefix(sql[i:], "--"): + // PostgreSQL ends a line comment at \n or a bare \r; the + // terminator itself is copied as ordinary text. + end := strings.IndexAny(sql[i:], "\r\n") + if end == -1 { + end = len(sql) + } else { + end += i + } + writeDoubled(&out, sql[i:end]) + i = end + case c == '/' && strings.HasPrefix(sql[i:], "/*"): + end := scanBlockComment(sql, i) + writeDoubled(&out, sql[i:end]) + i = end + default: + out.WriteByte(c) + i++ + } + } + + return out.String() +} + +// writeDoubled copies a skipped segment, still doubling every % in it. +func writeDoubled(out *strings.Builder, segment string) { + out.WriteString(strings.ReplaceAll(segment, "%", "%%")) +} + +// scanParamNumber reads a $N parameter reference at i and returns its digits +// and the index after them, or -1 when $ does not start a parameter. +func scanParamNumber(sql string, i int) (string, int) { + j := i + 1 + for j < len(sql) && sql[j] >= '0' && sql[j] <= '9' { + j++ + } + if j == i+1 { + return "", -1 + } + + return sql[i+1 : j], j +} + +// scanDollarQuote returns the index after a complete dollar-quoted string +// starting at i ($$...$$ or $tag$...$tag$), or -1 if i does not start one. +// A digit cannot start a tag - the caller already consumed $N parameters - +// and an unterminated quote swallows the rest of the input. +func scanDollarQuote(sql string, i int) int { + j := i + 1 + if j < len(sql) && (sql[j] == '_' || isAlphaByte(sql[j]) || sql[j] >= 0x80) { + for j < len(sql) && isIdentByte(sql[j]) { + j++ + } + } + if j >= len(sql) || sql[j] != '$' { + return -1 + } + delim := sql[i : j+1] + end := strings.Index(sql[j+1:], delim) + if end == -1 { + return len(sql) + } + + return j + 1 + end + len(delim) +} + +// isEscapeString reports whether the quote at i opens an E'...' escape +// string, where backslashes escape the following character. +func isEscapeString(sql string, i int) bool { + if i == 0 { + return false + } + if sql[i-1] != 'e' && sql[i-1] != 'E' { + return false + } + // The e must be its own token, not the tail of an identifier like "table". + return i < 2 || !isIdentContByte(sql[i-2]) +} + +// scanStringLiteral returns the index after a single-quoted literal starting +// at i, honoring quote doubling and, for escape strings, backslash escapes. +func scanStringLiteral(sql string, i int, escapes bool) int { + if !escapes { + return scanQuoted(sql, i, '\'') + } + j := i + 1 + for j < len(sql) { + switch { + case sql[j] == '\\': + j += 2 + case sql[j] != '\'': + j++ + case j+1 < len(sql) && sql[j+1] == '\'': + j += 2 + default: + return j + 1 + } + } + + return len(sql) +} + +// scanQuoted returns the index after a quoted region starting at i, where a +// doubled quote is an escape (used for "identifiers"). +func scanQuoted(sql string, i int, quote byte) int { + j := i + 1 + for j < len(sql) { + if sql[j] != quote { + j++ + + continue + } + if j+1 < len(sql) && sql[j+1] == quote { + j += 2 + + continue + } + + return j + 1 + } + + return len(sql) +} + +// scanBlockComment returns the index after a /* */ comment starting at i. +// PostgreSQL block comments nest. +func scanBlockComment(sql string, i int) int { + depth := 0 + j := i + for j < len(sql) { + switch { + case strings.HasPrefix(sql[j:], "/*"): + depth++ + j += 2 + case strings.HasPrefix(sql[j:], "*/"): + depth-- + j += 2 + if depth == 0 { + return j + } + default: + j++ + } + } + + return len(sql) +} + +func isAlphaByte(c byte) bool { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') +} + +// isIdentByte matches PostgreSQL's dolq_cont: dollar-quote tag bytes, which +// are the identifier bytes except the dollar sign. Bytes >= 0x80 cover the +// multi-byte characters PostgreSQL allows in identifiers and tags. +func isIdentByte(c byte) bool { + return isAlphaByte(c) || (c >= '0' && c <= '9') || c == '_' || c >= 0x80 +} + +// isIdentContByte matches PostgreSQL's ident_cont: identifier continuation +// bytes, which additionally include the dollar sign. +func isIdentContByte(c byte) bool { + return isIdentByte(c) || c == '$' +} diff --git a/internal/transform/psycopg_sql_test.go b/internal/transform/psycopg_sql_test.go new file mode 100644 index 00000000..ff872601 --- /dev/null +++ b/internal/transform/psycopg_sql_test.go @@ -0,0 +1,161 @@ +package transform + +import "testing" + +func TestRewritePsycopgSQL(t *testing.T) { + t.Parallel() + cases := []struct { + name string + sql string + want string + }{ + { + name: "single parameter", + sql: "SELECT id FROM t WHERE id = $1", + want: "SELECT id FROM t WHERE id = %(p1)s", + }, + { + name: "reused and multi-digit parameters", + sql: "SELECT $1, $2, $1, $12", + want: "SELECT %(p1)s, %(p2)s, %(p1)s, %(p12)s", + }, + { + name: "literal percent is doubled", + sql: "SELECT $1 WHERE note LIKE '50%' OR note LIKE 'a%b'", + want: "SELECT %(p1)s WHERE note LIKE '50%%' OR note LIKE 'a%%b'", + }, + { + name: "modulo operator is doubled", + sql: "SELECT id % 2 FROM t WHERE id = $1", + want: "SELECT id %% 2 FROM t WHERE id = %(p1)s", + }, + { + name: "parameter inside string literal stays text", + sql: "SELECT '$1', 'it''s $2', $3", + want: "SELECT '$1', 'it''s $2', %(p3)s", + }, + { + name: "escape string with escaped quote stays closed", + sql: `SELECT E'a\'b $1 %', $2`, + want: `SELECT E'a\'b $1 %%', %(p2)s`, + }, + { + name: "escape string honors quote doubling too", + sql: "SELECT E'it''s $1', $2", + want: "SELECT E'it''s $1', %(p2)s", + }, + { + name: "identifier ending in e does not start an escape string", + sql: "SELECT note FROM t WHERE note LIKE'%' AND id = $1", + want: "SELECT note FROM t WHERE note LIKE'%%' AND id = %(p1)s", + }, + { + name: "escape string at start of input", + sql: "'a' || $1", + want: "'a' || %(p1)s", + }, + { + name: "quoted identifier stays text", + sql: `SELECT "weird$1col", "a""b" FROM t WHERE x = $1`, + want: `SELECT "weird$1col", "a""b" FROM t WHERE x = %(p1)s`, + }, + { + name: "dollar quoted string stays text with percents doubled", + sql: "SELECT $$raw $1 50%$$, $tag$ $2 $tag$, $3", + want: "SELECT $$raw $1 50%%$$, $tag$ $2 $tag$, %(p3)s", + }, + { + name: "bare dollar and invalid tag are copied", + sql: "SELECT 1 $ 2 $abc, $1", + want: "SELECT 1 $ 2 $abc, %(p1)s", + }, + { + name: "identifier containing dollar-digits stays text", + sql: "SELECT col$2 FROM t WHERE id = $1", + want: "SELECT col$2 FROM t WHERE id = %(p1)s", + }, + { + name: "identifier with dollar-tag shaped tail stays text", + sql: "SELECT a$x$ FROM t WHERE id = $1", + want: "SELECT a$x$ FROM t WHERE id = %(p1)s", + }, + { + name: "multi-byte dollar quote tag stays text", + sql: "SELECT $\xc3\xa9$50% $1$\xc3\xa9$, $2", + want: "SELECT $\xc3\xa9$50%% $1$\xc3\xa9$, %(p2)s", + }, + { + name: "multi-byte identifier before string is not an escape string", + sql: "SELECT entr\xc3\xa9e'\\' AS x, $1", + want: "SELECT entr\xc3\xa9e'\\' AS x, %(p1)s", + }, + { + name: "line comment stays text", + sql: "SELECT $1 -- not $2 or 50%\nFROM t", + want: "SELECT %(p1)s -- not $2 or 50%%\nFROM t", + }, + { + name: "carriage return ends a line comment", + sql: "SELECT $1 -- note\r, $2", + want: "SELECT %(p1)s -- note\r, %(p2)s", + }, + { + name: "trailing line comment without newline", + sql: "SELECT $1 -- 50%", + want: "SELECT %(p1)s -- 50%%", + }, + { + name: "nested block comment stays text", + sql: "SELECT $1 /* outer /* $2 50% */ still */ FROM t", + want: "SELECT %(p1)s /* outer /* $2 50%% */ still */ FROM t", + }, + { + name: "unterminated block comment swallows the rest", + sql: "SELECT $1 /* dangling $2", + want: "SELECT %(p1)s /* dangling $2", + }, + { + name: "unterminated string swallows the rest", + sql: "SELECT $1, 'open $2", + want: "SELECT %(p1)s, 'open $2", + }, + { + name: "unterminated escape string swallows the rest", + sql: `SELECT $1, E'open\'`, + want: `SELECT %(p1)s, E'open\'`, + }, + { + name: "unterminated quoted identifier swallows the rest", + sql: `SELECT $1, "open $2`, + want: `SELECT %(p1)s, "open $2`, + }, + { + name: "unterminated dollar quote swallows the rest", + sql: "SELECT $$open $1", + want: "SELECT $$open $1", + }, + { + name: "dollar at end of input", + sql: "SELECT 1 $", + want: "SELECT 1 $", + }, + { + name: "slash without comment is copied", + sql: "SELECT $1 / 2", + want: "SELECT %(p1)s / 2", + }, + { + name: "dash without comment is copied", + sql: "SELECT $1 - 2", + want: "SELECT %(p1)s - 2", + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + if got := rewritePsycopgSQL(tc.sql); got != tc.want { + t.Errorf("rewritePsycopgSQL() = %q, want %q", got, tc.want) + } + }) + } +} diff --git a/internal/transform/queries.go b/internal/transform/queries.go index 45a5cc7a..8068195d 100644 --- a/internal/transform/queries.go +++ b/internal/transform/queries.go @@ -4,12 +4,90 @@ import ( "slices" "strings" + "github.com/rayakame/sqlc-gen-better-python/internal/config" "github.com/rayakame/sqlc-gen-better-python/internal/model" "github.com/rayakame/sqlc-gen-better-python/internal/utils" "github.com/sqlc-dev/plugin-sdk-go/metadata" "github.com/sqlc-dev/plugin-sdk-go/plugin" ) +// plainParams builds the expanded parameter list of a query, keeping names +// clear of the implicit first argument and of the locals generated bodies +// introduce. +func (t *Transformer) plainParams(pluginQuery *plugin.Query) []model.QueryValue { + params := make([]model.QueryValue, 0, len(pluginQuery.Params)) + seen := make(map[string]int, len(pluginQuery.Params)+1) + // The implicit first argument of every generated function must never + // collide with a parameter name: a column literally named "conn" (or + // "self" in classes mode) would otherwise produce a duplicate argument + // and a SyntaxError in the generated module. + if t.config.EmitClasses { + seen["self"]++ + } else { + seen["conn"]++ + } + // Slice queries materialize the expanded SQL into a local named "sql" + // before any parameter is read; a parameter with that name would be + // silently overwritten by the query text. + for _, param := range pluginQuery.Params { + if param.GetColumn().GetIsSqlcSlice() { + seen["sql"]++ + + break + } + } + // psycopg query bodies introduce locals a parameter must not clobber: an + // overlong params dict hoists into "sql_params", :execrows reads the + // cursor via "cur", :one fetches into "row", and :many may define a + // nested "_decode_hook". + if t.config.SqlDriver == config.SQLDriverPsycopgAsync { + seen["sql_params"]++ + switch pluginQuery.Cmd { + case metadata.CmdExecRows: + seen["cur"]++ + case metadata.CmdOne: + seen["row"]++ + case metadata.CmdMany: + seen["_decode_hook"]++ + } + } + for _, param := range pluginQuery.Params { + params = append(params, model.QueryValue{ + Name: model.DedupName(model.ParamName(param), seen), + Type: t.buildPyType(param.Column), + Number: param.Number, + }) + } + + return params +} + +// bundledParams builds the single Params-class parameter used by :copyfrom +// and query_parameter_limit queries. Field order follows the sqlc parameter +// array, and each field keeps its parameter number for name-binding drivers. +func (t *Transformer) bundledParams(pluginQuery *plugin.Query, queryName string, isCopyFrom bool) []model.QueryValue { + columns := make([]pyColumn, 0, len(pluginQuery.Params)) + for _, param := range pluginQuery.Params { + columns = append(columns, pyColumn{ + column: param.Column, + embed: nil, + }) + } + table := t.columnsToClass(queryName+"Params", columns) + for i := range table.Columns { + table.Columns[i].Number = pluginQuery.Params[i].Number + } + + return []model.QueryValue{ + { + Table: utils.ToPtr(table), + Name: "params", + Type: model.PyType{Type: table.Name, IsList: isCopyFrom}, + EmitTable: true, + }, + } +} + func (t *Transformer) BuildQueries(tables []model.Table) []model.Query { queries := make([]model.Query, 0, len(t.req.Queries)) for _, pluginQuery := range t.req.Queries { @@ -40,52 +118,19 @@ func (t *Transformer) BuildQueries(tables []model.Table) []model.Query { ModuleName: moduleName, Table: pluginQuery.InsertIntoTable, } + // psycopg rejects PostgreSQL-native $N placeholders and scans the + // whole text for pyformat ones as soon as parameters are passed, so + // parameterized queries are rewritten once here. :copyfrom never + // executes its SQL - the driver builds a COPY statement instead. + if t.config.SqlDriver == config.SQLDriverPsycopgAsync && + len(pluginQuery.Params) > 0 && query.Cmd != metadata.CmdCopyFrom { + query.SQL = rewritePsycopgSQL(pluginQuery.Text) + } if query.Cmd == metadata.CmdCopyFrom || t.config.IsOverQueryParameterLimit(len(pluginQuery.Params)) { - columns := make([]pyColumn, 0, len(pluginQuery.Params)) - for _, param := range pluginQuery.Params { - columns = append(columns, pyColumn{ - column: param.Column, - embed: nil, - }) - } - table := t.columnsToClass(query.QueryName+"Params", columns) - query.Params = []model.QueryValue{ - { - Table: utils.ToPtr(table), - Name: "params", - Type: model.PyType{Type: table.Name, IsList: query.Cmd == metadata.CmdCopyFrom}, - EmitTable: true, - }, - } + query.Params = t.bundledParams(pluginQuery, query.QueryName, query.Cmd == metadata.CmdCopyFrom) } else { - query.Params = make([]model.QueryValue, 0, len(pluginQuery.Params)) - seen := make(map[string]int, len(pluginQuery.Params)+1) - // The implicit first argument of every generated function must - // never collide with a parameter name: a column literally named - // "conn" (or "self" in classes mode) would otherwise produce a - // duplicate argument and a SyntaxError in the generated module. - if t.config.EmitClasses { - seen["self"]++ - } else { - seen["conn"]++ - } - // Slice queries materialize the expanded SQL into a local named - // "sql" before any parameter is read; a parameter with that name - // would be silently overwritten by the query text. - for _, param := range pluginQuery.Params { - if param.GetColumn().GetIsSqlcSlice() { - seen["sql"]++ - - break - } - } - for _, param := range pluginQuery.Params { - query.Params = append(query.Params, model.QueryValue{ - Name: model.DedupName(model.ParamName(param), seen), - Type: t.buildPyType(param.Column), - }) - } + query.Params = t.plainParams(pluginQuery) } if query.Cmd == metadata.CmdExecLastId { diff --git a/internal/transform/queries_test.go b/internal/transform/queries_test.go index 95c1cc8a..bf34ce5f 100644 --- a/internal/transform/queries_test.go +++ b/internal/transform/queries_test.go @@ -147,9 +147,9 @@ func TestBuildQueriesExecBasics(t *testing.T) { t.Errorf("Returns = %+v, want %+v", query.Returns, want) } wantParams := []model.QueryValue{ - {Name: "name", Type: pyStr}, - {Name: "dollar_2", Type: pyInt}, - {Name: "for_", Type: pyStr}, + {Name: "name", Type: pyStr, Number: 1}, + {Name: "dollar_2", Type: pyInt, Number: 2}, + {Name: "for_", Type: pyStr, Number: 3}, } if len(query.Params) != len(wantParams) { t.Fatalf("Params = %+v, want %d params", query.Params, len(wantParams)) @@ -166,6 +166,8 @@ func TestBuildQueriesImplicitArgCollision(t *testing.T) { cases := []struct { name string emitClasses bool + driver config.SQLDriver + cmd string column string sqlcSlice bool want string @@ -178,15 +180,57 @@ func TestBuildQueriesImplicitArgCollision(t *testing.T) { // before binding, so the name is reserved exactly there. {name: "sql collides in a slice query", emitClasses: false, column: "sql", sqlcSlice: true, want: "sql_2"}, {name: "sql is free without slices", emitClasses: false, column: "sql", want: "sql"}, + // psycopg query bodies introduce locals of their own: the hoisted + // params dict, the :execrows cursor, and the :one row. + { + name: "sql_params collides for psycopg", + driver: config.SQLDriverPsycopgAsync, + column: "sql_params", + want: "sql_params_2", + }, + {name: "sql_params is free for asyncpg", driver: config.SQLDriverAsyncpg, column: "sql_params", want: "sql_params"}, + { + name: "cur collides in a psycopg execrows query", + driver: config.SQLDriverPsycopgAsync, + cmd: ":execrows", + column: "cur", + want: "cur_2", + }, + {name: "cur is free in a psycopg exec query", driver: config.SQLDriverPsycopgAsync, column: "cur", want: "cur"}, + { + name: "row collides in a psycopg one query", + driver: config.SQLDriverPsycopgAsync, + cmd: ":one", + column: "row", + want: "row_2", + }, + {name: "row is free in a psycopg exec query", driver: config.SQLDriverPsycopgAsync, column: "row", want: "row"}, + { + name: "decode hook collides in a psycopg many query", + driver: config.SQLDriverPsycopgAsync, + cmd: ":many", + column: "_decode_hook", + want: "_decode_hook_2", + }, + { + name: "decode hook is free in a psycopg exec query", + driver: config.SQLDriverPsycopgAsync, + column: "_decode_hook", + want: "_decode_hook", + }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { t.Parallel() column := queryCol(tc.column, "int4", nil) column.IsSqlcSlice = tc.sqlcSlice - query := buildSingleQuery(t, &config.Config{EmitClasses: tc.emitClasses}, &plugin.Query{ + cmd := tc.cmd + if cmd == "" { + cmd = ":exec" + } + query := buildSingleQuery(t, &config.Config{EmitClasses: tc.emitClasses, SqlDriver: tc.driver}, &plugin.Query{ Name: "Ping", - Cmd: ":exec", + Cmd: cmd, Params: []*plugin.Parameter{{Number: 1, Column: column}}, }) @@ -259,9 +303,9 @@ func TestBuildQueriesCopyFrom(t *testing.T) { t.Errorf("params class identifier = %+v, want an empty identifier", param.Table.Identifier) } wantColumns := []model.Column{ - {Name: "id_", DBName: "id", Type: pyInt}, - {Name: "name", DBName: "name", Type: pyStr}, - {Name: "name_2", DBName: "name", Type: pyStr}, + {Name: "id_", DBName: "id", Type: pyInt, Number: 1}, + {Name: "name", DBName: "name", Type: pyStr, Number: 2}, + {Name: "name_2", DBName: "name", Type: pyStr, Number: 3}, } if len(param.Table.Columns) != len(wantColumns) { t.Fatalf("params class columns = %+v, want %d columns", param.Table.Columns, len(wantColumns)) @@ -508,3 +552,76 @@ func TestBuildQueriesEmbedUnknownTable(t *testing.T) { t.Errorf("row column[0] = %+v, want plain column %+v", query.Returns.Table.Columns[0], want) } } + +func TestBuildQueriesPsycopgSQLRewrite(t *testing.T) { + t.Parallel() + cases := []struct { + name string + driver config.SQLDriver + query *plugin.Query + wantSQL string + }{ + { + name: "parameterized query is rewritten for psycopg", + driver: config.SQLDriverPsycopgAsync, + query: &plugin.Query{ + Name: "GetAuthor", + Cmd: ":one", + Text: "SELECT name FROM test_authors WHERE id = $1 AND name LIKE 'a%'", + Params: []*plugin.Parameter{ + {Number: 1, Column: queryCol("id", "int4", nil)}, + }, + Columns: []*plugin.Column{queryCol("name", "text", nil)}, + }, + wantSQL: "SELECT name FROM test_authors WHERE id = %(p1)s AND name LIKE 'a%%'", + }, + { + name: "parameterless query stays untouched", + driver: config.SQLDriverPsycopgAsync, + query: &plugin.Query{ + Name: "CountAuthors", + Cmd: ":one", + Text: "SELECT count(*) FROM test_authors WHERE name LIKE 'a%'", + Columns: []*plugin.Column{queryCol("count", "int8", nil)}, + }, + wantSQL: "SELECT count(*) FROM test_authors WHERE name LIKE 'a%'", + }, + { + name: "copyfrom stays untouched", + driver: config.SQLDriverPsycopgAsync, + query: &plugin.Query{ + Name: "CopyAuthors", + Cmd: ":copyfrom", + Text: "INSERT INTO test_authors (id) VALUES ($1)", + Params: []*plugin.Parameter{ + {Number: 1, Column: queryCol("id", "int4", nil)}, + }, + InsertIntoTable: &plugin.Identifier{Name: "test_authors"}, + }, + wantSQL: "INSERT INTO test_authors (id) VALUES ($1)", + }, + { + name: "asyncpg keeps native placeholders", + driver: config.SQLDriverAsyncpg, + query: &plugin.Query{ + Name: "GetAuthor", + Cmd: ":one", + Text: "SELECT name FROM test_authors WHERE id = $1", + Params: []*plugin.Parameter{ + {Number: 1, Column: queryCol("id", "int4", nil)}, + }, + Columns: []*plugin.Column{queryCol("name", "text", nil)}, + }, + wantSQL: "SELECT name FROM test_authors WHERE id = $1", + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + query := buildSingleQuery(t, &config.Config{SqlDriver: tc.driver}, tc.query) + if query.SQL != tc.wantSQL { + t.Errorf("SQL = %q, want %q", query.SQL, tc.wantSQL) + } + }) + } +} diff --git a/internal/writer/docstrings.go b/internal/writer/docstrings.go index 305e45be..4815498d 100644 --- a/internal/writer/docstrings.go +++ b/internal/writer/docstrings.go @@ -189,10 +189,15 @@ func (w *CodeWriter) WriteQueryClassConnDocstring(connType string) { // --- QueryResults docstrings -------------------------------------------------- // WriteQueryResultsClassDocstring writes the QueryResults class docstring. -func (w *CodeWriter) WriteQueryResultsClassDocstring(connType, resultType string) { +// namedParams switches the argument documentation from *args to params. +func (w *CodeWriter) WriteQueryResultsClassDocstring(connType, resultType string, namedParams bool) { if !w.DocstringsEnabled() { return } + argsName, argsDesc := "*args", "Arguments that should be sent when executing the sql query." + if namedParams { + argsName, argsDesc = "params", "Named arguments that should be sent when executing the sql query." + } w.WriteIndentedString(1, `"""Helper class that allows both iteration and normal fetching of data from the db.`) if w.docstringConvention == config.DocstringConventionNumpy { w.NNewLine(2) @@ -207,8 +212,8 @@ func (w *CodeWriter) WriteQueryResultsClassDocstring(connType, resultType string memberIndent, fmt.Sprintf("A callback that turns an `%s` object into `T` that will be returned.", resultType), ) - w.WriteIndentedLine(1, "*args") - w.WriteIndentedLine(memberIndent, "Arguments that should be sent when executing the sql query.") + w.WriteIndentedLine(1, argsName) + w.WriteIndentedLine(memberIndent, argsDesc) w.NewLine() w.WriteIndentedLine(1, `"""`) } else { @@ -218,10 +223,15 @@ func (w *CodeWriter) WriteQueryResultsClassDocstring(connType, resultType string } // WriteQueryResultsInitDocstring writes the QueryResults __init__ docstring. -func (w *CodeWriter) WriteQueryResultsInitDocstring(connType, resultType string) { +// namedParams switches the argument documentation from *args to params. +func (w *CodeWriter) WriteQueryResultsInitDocstring(connType, resultType string, namedParams bool) { if !w.DocstringsEnabled() { return } + argsName, argsDesc := "*args", "Arguments that should be sent when executing the sql query." + if namedParams { + argsName, argsDesc = "params", "Named arguments that should be sent when executing the sql query." + } w.WriteIndentedString(memberIndent, `"""Initialize the QueryResults instance.`) switch w.docstringConvention { case config.DocstringConventionNone: @@ -239,8 +249,8 @@ func (w *CodeWriter) WriteQueryResultsInitDocstring(connType, resultType string) detailIndent, fmt.Sprintf("A callback that turns an `%s` object into `T` that will be returned.", resultType), ) - w.WriteIndentedLine(entryIndent, "*args:") - w.WriteIndentedLine(detailIndent, "Arguments that should be sent when executing the sql query.") + w.WriteIndentedLine(entryIndent, argsName+":") + w.WriteIndentedLine(detailIndent, argsDesc) w.WriteIndentedLine(memberIndent, `"""`) case config.DocstringConventionPEP257: w.NNewLine(2) @@ -254,7 +264,7 @@ func (w *CodeWriter) WriteQueryResultsInitDocstring(connType, resultType string) memberIndent, fmt.Sprintf("decode_hook -- A callback that turns an `%s` object into `T` that will be returned.", resultType), ) - w.WriteIndentedLine(memberIndent, "*args -- Arguments that should be sent when executing the sql query.") + w.WriteIndentedLine(memberIndent, argsName+" -- "+argsDesc) w.WriteIndentedLine(memberIndent, `"""`) } } @@ -382,11 +392,12 @@ func (w *CodeWriter) WriteQueryFunctionDocstring(lvl int, query *model.Query, co summaryFmt = "Execute SQL query with `name: %s %s`." case metadata.CmdExecRows: summaryFmt = "Execute SQL query with `name: %s %s` and return the number of affected rows." - // Both sqlite drivers return cursor.rowcount, which is -1 for - // non-DML statements per DB-API; only asyncpg's status-string parse - // falls back to 0. + // The sqlite drivers and psycopg return cursor.rowcount, which is -1 + // for statements without a row count; only asyncpg's status-string + // parse falls back to 0. noRows := "0" - if w.docstringDriver == config.SQLDriverAioSQLite || w.docstringDriver == config.SQLDriverSQLite { + if w.docstringDriver == config.SQLDriverAioSQLite || w.docstringDriver == config.SQLDriverSQLite || + w.docstringDriver == config.SQLDriverPsycopgAsync { noRows = "-1" } ret = &retDoc{ diff --git a/internal/writer/docstrings_test.go b/internal/writer/docstrings_test.go index 70e08564..3aa2d590 100644 --- a/internal/writer/docstrings_test.go +++ b/internal/writer/docstrings_test.go @@ -363,7 +363,7 @@ func TestWriteQueryResultsClassDocstring(t *testing.T) { name: "none", conv: config.DocstringConventionNone, write: func(w *writer.CodeWriter) { - w.WriteQueryResultsClassDocstring("asyncpg.Connection", "asyncpg.Record") + w.WriteQueryResultsClassDocstring("asyncpg.Connection", "asyncpg.Record", false) }, want: "", }, @@ -371,7 +371,7 @@ func TestWriteQueryResultsClassDocstring(t *testing.T) { name: "numpy has parameters section", conv: config.DocstringConventionNumpy, write: func(w *writer.CodeWriter) { - w.WriteQueryResultsClassDocstring("asyncpg.Connection", "asyncpg.Record") + w.WriteQueryResultsClassDocstring("asyncpg.Connection", "asyncpg.Record", false) }, want: lines( ` """Helper class that allows both iteration and normal fetching of data from the db.`, @@ -395,7 +395,7 @@ func TestWriteQueryResultsClassDocstring(t *testing.T) { name: "pep257 stays one line", conv: config.DocstringConventionPEP257, write: func(w *writer.CodeWriter) { - w.WriteQueryResultsClassDocstring("asyncpg.Connection", "asyncpg.Record") + w.WriteQueryResultsClassDocstring("asyncpg.Connection", "asyncpg.Record", false) }, want: lines(` """Helper class that allows both iteration and normal fetching of data from the db."""`, ``), }, @@ -409,7 +409,7 @@ func TestWriteQueryResultsInitDocstring(t *testing.T) { name: "none", conv: config.DocstringConventionNone, write: func(w *writer.CodeWriter) { - w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record") + w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record", false) }, want: "", }, @@ -417,7 +417,7 @@ func TestWriteQueryResultsInitDocstring(t *testing.T) { name: "numpy", conv: config.DocstringConventionNumpy, write: func(w *writer.CodeWriter) { - w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record") + w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record", false) }, want: lines(` """Initialize the QueryResults instance."""`), }, @@ -425,7 +425,7 @@ func TestWriteQueryResultsInitDocstring(t *testing.T) { name: "google", conv: config.DocstringConventionGoogle, write: func(w *writer.CodeWriter) { - w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record") + w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record", false) }, want: lines( ` """Initialize the QueryResults instance.`, @@ -446,7 +446,7 @@ func TestWriteQueryResultsInitDocstring(t *testing.T) { name: "pep257", conv: config.DocstringConventionPEP257, write: func(w *writer.CodeWriter) { - w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record") + w.WriteQueryResultsInitDocstring("asyncpg.Connection", "asyncpg.Record", false) }, want: lines( ` """Initialize the QueryResults instance.`, diff --git a/internal/writer/queryresults.go b/internal/writer/queryresults.go index 8006b803..2bc85651 100644 --- a/internal/writer/queryresults.go +++ b/internal/writer/queryresults.go @@ -27,37 +27,18 @@ func (w *QueryResultsWriter) WriteQueryResultsClassHeader( driverReturnType string, async bool, ) { - // PEP 695 class-scoped type parameter: no module-level TypeVar and no - // typing.Generic base needed on Python 3.12+. - w.writer.WriteLine("class QueryResults[T]:") - w.writer.WriteQueryResultsClassDocstring(connType, driverReturnType) - w.writer.WriteIndentedLine(1, `__slots__ = ("_args", "_conn", "_cursor", "_decode_hook", "_iterator", "_sql")`) - w.writer.NewLine() - w.writer.WriteIndentedLine(1, "def __init__(") - w.writer.WriteIndentedLine(methodBodyIndent, "self,") - w.writer.WriteIndentedLine(methodBodyIndent, fmt.Sprintf("conn: %s,", connType)) - w.writer.WriteIndentedLine(methodBodyIndent, "sql: str,") - w.writer.WriteIndentedLine(methodBodyIndent, fmt.Sprintf("decode_hook: collections.abc.Callable[[%s], T],", driverReturnType)) - w.writer.WriteIndentedLine(methodBodyIndent, "*args: QueryResultsArgsType,") - w.writer.WriteIndentedLine(1, ") -> None:") - w.writer.WriteQueryResultsInitDocstring(connType, driverReturnType) - w.writer.WriteIndentedLine(methodBodyIndent, "self._conn = conn") - w.writer.WriteIndentedLine(methodBodyIndent, "self._sql = sql") - w.writer.WriteIndentedLine(methodBodyIndent, "self._decode_hook = decode_hook") - w.writer.WriteIndentedLine(methodBodyIndent, "self._args = args") - for _, line := range initFields { - w.writer.WriteIndentedLine(methodBodyIndent, line) - } - w.writer.NewLine() + w.writeClassHeader(connType, initFields, driverReturnType, async, false) +} - if async { - w.writer.WriteIndentedLine(1, "def __aiter__(self) -> QueryResults[T]:") - } else { - w.writer.WriteIndentedLine(1, "def __iter__(self) -> QueryResults[T]:") - } - w.writer.WriteQueryResultsIterDocstring(async) - w.writer.WriteIndentedLine(methodBodyIndent, "return self") - w.writer.NewLine() +// WriteQueryResultsClassHeaderNamedParams writes the header variant for +// drivers that bind parameters by name: a params dict replaces *args. +func (w *QueryResultsWriter) WriteQueryResultsClassHeaderNamedParams( + connType string, + initFields []string, + driverReturnType string, + async bool, +) { + w.writeClassHeader(connType, initFields, driverReturnType, async, true) } // WriteQueryResultsCallFunction writes the synchronous __call__ method. @@ -87,3 +68,53 @@ func (w *QueryResultsWriter) WriteQueryResultsAwaitFunction(wrapperLines []strin w.writer.NewLine() w.writer.WriteIndentedLine(methodBodyIndent, "return _wrapper().__await__()") } + +func (w *QueryResultsWriter) writeClassHeader( + connType string, + initFields []string, + driverReturnType string, + async bool, + namedParams bool, +) { + slots := `__slots__ = ("_args", "_conn", "_cursor", "_decode_hook", "_iterator", "_sql")` + argsParam, argsAssign := "*args: QueryResultsArgsType,", "self._args = args" + sqlParam, sqlAssign := "sql: str,", "self._sql = sql" + if namedParams { + slots = `__slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql")` + argsParam, argsAssign = "params: dict[str, QueryResultsArgsType] | None = None,", "self._params = params" + // psycopg's typed execute() requires LiteralString query text, and + // the attribute needs the annotation too - inference widens to str. + sqlParam, sqlAssign = "sql: typing.LiteralString,", "self._sql: typing.LiteralString = sql" + } + // PEP 695 class-scoped type parameter: no module-level TypeVar and no + // typing.Generic base needed on Python 3.12+. + w.writer.WriteLine("class QueryResults[T]:") + w.writer.WriteQueryResultsClassDocstring(connType, driverReturnType, namedParams) + w.writer.WriteIndentedLine(1, slots) + w.writer.NewLine() + w.writer.WriteIndentedLine(1, "def __init__(") + w.writer.WriteIndentedLine(methodBodyIndent, "self,") + w.writer.WriteIndentedLine(methodBodyIndent, fmt.Sprintf("conn: %s,", connType)) + w.writer.WriteIndentedLine(methodBodyIndent, sqlParam) + w.writer.WriteIndentedLine(methodBodyIndent, fmt.Sprintf("decode_hook: collections.abc.Callable[[%s], T],", driverReturnType)) + w.writer.WriteIndentedLine(methodBodyIndent, argsParam) + w.writer.WriteIndentedLine(1, ") -> None:") + w.writer.WriteQueryResultsInitDocstring(connType, driverReturnType, namedParams) + w.writer.WriteIndentedLine(methodBodyIndent, "self._conn = conn") + w.writer.WriteIndentedLine(methodBodyIndent, sqlAssign) + w.writer.WriteIndentedLine(methodBodyIndent, "self._decode_hook = decode_hook") + w.writer.WriteIndentedLine(methodBodyIndent, argsAssign) + for _, line := range initFields { + w.writer.WriteIndentedLine(methodBodyIndent, line) + } + w.writer.NewLine() + + if async { + w.writer.WriteIndentedLine(1, "def __aiter__(self) -> QueryResults[T]:") + } else { + w.writer.WriteIndentedLine(1, "def __iter__(self) -> QueryResults[T]:") + } + w.writer.WriteQueryResultsIterDocstring(async) + w.writer.WriteIndentedLine(methodBodyIndent, "return self") + w.writer.NewLine() +} diff --git a/internal/writer/queryresults_test.go b/internal/writer/queryresults_test.go index 022cec2b..e3f95dc6 100644 --- a/internal/writer/queryresults_test.go +++ b/internal/writer/queryresults_test.go @@ -217,3 +217,87 @@ func TestWriteQueryResultsAwaitFunction(t *testing.T) { } }) } + +func TestWriteQueryResultsClassHeaderNamedParams(t *testing.T) { + t.Parallel() + w := newWriter(config.DocstringConventionNone) + w.QueryResults.WriteQueryResultsClassHeaderNamedParams( + "ConnectionLike", + []string{"self._cursor = None"}, + "psycopg.rows.TupleRow", + true, + ) + want := strings.Join([]string{ + "class QueryResults[T]:", + " __slots__ = (\"_conn\", \"_cursor\", \"_decode_hook\", \"_iterator\", \"_params\", \"_sql\")", + "", + " def __init__(", + " self,", + " conn: ConnectionLike,", + " sql: typing.LiteralString,", + " decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T],", + " params: dict[str, QueryResultsArgsType] | None = None,", + " ) -> None:", + " self._conn = conn", + " self._sql: typing.LiteralString = sql", + " self._decode_hook = decode_hook", + " self._params = params", + " self._cursor = None", + "", + " def __aiter__(self) -> QueryResults[T]:", + " return self", + "", + "", + }, "\n") + if got := w.String(); got != want { + t.Errorf("WriteQueryResultsClassHeaderNamedParams() = %q, want %q", got, want) + } +} + +func TestWriteQueryResultsClassHeaderNamedParamsDocstrings(t *testing.T) { + t.Parallel() + cases := []struct { + name string + convention config.DocstringConvention + wants []string + }{ + { + // The class docstring lists parameters only under numpy. + name: "numpy class docstring names params", + convention: config.DocstringConventionNumpy, + wants: []string{ + " params\n Named arguments that should be sent when executing the sql query.", + }, + }, + { + name: "google init docstring names params", + convention: config.DocstringConventionGoogle, + wants: []string{ + " params:\n Named arguments that should be sent when executing the sql query.", + }, + }, + { + name: "pep257 init docstring names params", + convention: config.DocstringConventionPEP257, + wants: []string{ + " params -- Named arguments that should be sent when executing the sql query.", + }, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + w := newWriter(tc.convention) + w.QueryResults.WriteQueryResultsClassHeaderNamedParams("ConnectionLike", nil, "psycopg.rows.TupleRow", true) + got := w.String() + if strings.Contains(got, "*args") { + t.Errorf("output still mentions *args: %q", got) + } + for _, want := range tc.wants { + if !strings.Contains(got, want) { + t.Errorf("output missing %q\ngot: %q", want, got) + } + } + }) + } +} diff --git a/noxfile.py b/noxfile.py index 8affbcd2..1e5a16ae 100644 --- a/noxfile.py +++ b/noxfile.py @@ -15,6 +15,7 @@ DRIVER_PATHS = { "asyncpg": PATH_TO_PROJECT / "test" / "driver_asyncpg", + "psycopg_async": PATH_TO_PROJECT / "test" / "driver_psycopg_async", "aiosqlite": PATH_TO_PROJECT / "test" / "driver_aiosqlite", "sqlite3": PATH_TO_PROJECT / "test" / "driver_sqlite3", } @@ -22,7 +23,7 @@ SQLC_CONFIGS = ["sqlc.yaml"] options.default_venv_backend = "uv" -options.sessions = ["ruff_format", "asyncpg", "sqlite3", "aiosqlite", "pyright", "ruff", "pytest"] +options.sessions = ["ruff_format", "asyncpg", "psycopg_async", "sqlite3", "aiosqlite", "pyright", "ruff", "pytest"] DEFAULT_POSTGRES_URI = os.getenv("POSTGRES_URI", "postgresql://root:187187@localhost:5432/root") @@ -137,6 +138,24 @@ def asyncpg_check(session: nox.Session) -> None: session.run("ruff", "check", *session.posargs, DRIVER_PATHS["asyncpg"]) +@nox.session(reuse_venv=True) +def psycopg_async(session: nox.Session) -> None: + uv_sync(session, include_self=True, groups=["pyright", "ruff"]) + + sqlc_generate(session, "psycopg_async") + session.run("pyright", DRIVER_PATHS["psycopg_async"]) + session.run("ruff", "check", *session.posargs, DRIVER_PATHS["psycopg_async"]) + + +@nox.session(reuse_venv=True) +def psycopg_async_check(session: nox.Session) -> None: + uv_sync(session, include_self=True, groups=["pyright", "ruff"]) + + sqlc_check(session, "psycopg_async") + session.run("pyright", DRIVER_PATHS["psycopg_async"]) + session.run("ruff", "check", *session.posargs, DRIVER_PATHS["psycopg_async"]) + + @nox.session(reuse_venv=True) def pyright(session: nox.Session) -> None: uv_sync(session, include_self=True, groups=["pyright"]) diff --git a/pyproject.toml b/pyproject.toml index 5bcf0855..d332a7b3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,6 +6,7 @@ requires-python = ">=3.12.0,<3.15.0" dependencies = [ "aiosqlite>=0.21.0", "asyncpg>=0.31.0", + "psycopg[binary]>=3.2", "attrs>=25.3.0", "ciso8601>=2.3.2", "msgspec>=0.19.0", diff --git a/scripts/build/build.bat b/scripts/build/build.bat index ba55bf71..2c4b75b1 100644 --- a/scripts/build/build.bat +++ b/scripts/build/build.bat @@ -5,7 +5,7 @@ REM ------------------------------ REM 1) CONFIGURATION - add folders here REM (paths are relative to repo root) REM ------------------------------ -set "TARGET_DIRS=test\driver_asyncpg test\driver_aiosqlite test\driver_sqlite3" +set "TARGET_DIRS=test\driver_asyncpg test\driver_psycopg_async test\driver_aiosqlite test\driver_sqlite3" set "SQLC_CONFIG_NAMES=sqlc.yaml" REM ------------------------------ diff --git a/scripts/build/build.sh b/scripts/build/build.sh index bcc4a4ad..8a253be3 100644 --- a/scripts/build/build.sh +++ b/scripts/build/build.sh @@ -4,7 +4,7 @@ set -euo pipefail # ------------------------------ # 1) CONFIGURATION # ------------------------------ -TARGET_DIRS=("test/driver_asyncpg" "test/driver_aiosqlite" "test/driver_sqlite3") +TARGET_DIRS=("test/driver_asyncpg" "test/driver_psycopg_async" "test/driver_aiosqlite" "test/driver_sqlite3") SQLC_CONFIG_NAMES=("sqlc.yaml") # ------------------------------ diff --git a/sqlc.yaml b/sqlc.yaml index a16635a6..1a853da3 100644 --- a/sqlc.yaml +++ b/sqlc.yaml @@ -3,7 +3,7 @@ plugins: - name: python wasm: url: file://sqlc-gen-better-python.wasm - sha256: 78698bcbf8188223f72f98228792f79a1e93dbaa20a6d41995e6eee962a3eb39 + sha256: 237081a0a5dfc42156c4cf1fd9b0d20fe8c4bcbbbcb9f9a18fb31f0151b9505e sql: - schema: test/schema.sql queries: test/queries.sql diff --git a/test/conftest.py b/test/conftest.py index db64eaae..f0506fa4 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -22,10 +22,13 @@ import asyncio import pathlib import sqlite3 +import sys import typing import aiosqlite import asyncpg +import psycopg +import psycopg.rows import pytest if typing.TYPE_CHECKING: @@ -33,9 +36,23 @@ import pytest_asyncio ASYNCPG_PATH = pathlib.Path(__file__).parent / "driver_asyncpg" +PSYCOPG_ASYNC_PATH = pathlib.Path(__file__).parent / "driver_psycopg_async" AIOSQLITE_PATH = pathlib.Path(__file__).parent / "driver_aiosqlite" SQLITE3_PATH = pathlib.Path(__file__).parent / "driver_sqlite3" +# Both postgres suites share the same tables, so their session teardowns must +# clean the same list; a single constant keeps them from diverging. +_POSTGRES_CLEANUP: typing.Final = """ + DELETE FROM test_postgres_types; + DELETE FROM test_inner_postgres_types; + DELETE FROM test_copy_from; + DELETE FROM test_copy_override; + DELETE FROM test_converters; + DELETE FROM test_converter_array; + DELETE FROM test_invalid_identifiers; + DELETE FROM "3rd_party_stats"; +""" + def pytest_addoption(parser: pytest.Parser) -> None: parser.addoption( @@ -77,16 +94,34 @@ async def asyncpg_conn( await conn.execute((ASYNCPG_PATH / "schema.sql").read_text()) yield conn - await conn.execute(""" - DELETE FROM test_postgres_types; - DELETE FROM test_inner_postgres_types; - DELETE FROM test_copy_from; - DELETE FROM test_copy_override; - DELETE FROM test_converters; - DELETE FROM test_converter_array; - DELETE FROM test_invalid_identifiers; - DELETE FROM "3rd_party_stats"; - """) + await conn.execute(_POSTGRES_CLEANUP) + await conn.close() + + +if sys.platform == "win32": + + @pytest.fixture(scope="session") + def event_loop_policy() -> asyncio.AbstractEventLoopPolicy: + # psycopg's async support refuses the default ProactorEventLoop. + return asyncio.WindowsSelectorEventLoopPolicy() + + +@pytest_asyncio.fixture(scope="session", loop_scope="session") +async def psycopg_async_conn( + request: pytest.FixtureRequest, +) -> collections.abc.AsyncGenerator[psycopg.AsyncConnection[psycopg.rows.TupleRow], typing.Any]: + dsn = get_dsn(request.config) + # autocommit matches asyncpg's per-statement semantics and keeps one + # failing test from poisoning the shared connection's transaction. + conn = await psycopg.AsyncConnection.connect(dsn, autocommit=True) + + # The schema shares its tables with the asyncpg suite; both suites clean + # the same tables at session end, which is idempotent. psycopg's execute + # is typed LiteralString, hence the cast for the file contents. + schema = typing.cast("typing.LiteralString", (PSYCOPG_ASYNC_PATH / "schema.sql").read_text()) + await conn.execute(schema) + yield conn + await conn.execute(_POSTGRES_CLEANUP) await conn.close() diff --git a/test/driver_aiosqlite/attrs/classes/__init__.py b/test/driver_aiosqlite/attrs/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/attrs/classes/__init__.py +++ b/test/driver_aiosqlite/attrs/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/attrs/classes/models.py b/test/driver_aiosqlite/attrs/classes/models.py index 7d6aba78..85fb2161 100644 --- a/test/driver_aiosqlite/attrs/classes/models.py +++ b/test/driver_aiosqlite/attrs/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/attrs/classes/queries.py b/test/driver_aiosqlite/attrs/classes/queries.py index 1060d3eb..32f42828 100644 --- a/test/driver_aiosqlite/attrs/classes/queries.py +++ b/test/driver_aiosqlite/attrs/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/attrs/functions/__init__.py b/test/driver_aiosqlite/attrs/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/attrs/functions/__init__.py +++ b/test/driver_aiosqlite/attrs/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/attrs/functions/models.py b/test/driver_aiosqlite/attrs/functions/models.py index 7d6aba78..85fb2161 100644 --- a/test/driver_aiosqlite/attrs/functions/models.py +++ b/test/driver_aiosqlite/attrs/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/attrs/functions/queries.py b/test/driver_aiosqlite/attrs/functions/queries.py index 858a7a2e..1bd04ed8 100644 --- a/test/driver_aiosqlite/attrs/functions/queries.py +++ b/test/driver_aiosqlite/attrs/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/dataclass/classes/__init__.py b/test/driver_aiosqlite/dataclass/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/dataclass/classes/__init__.py +++ b/test/driver_aiosqlite/dataclass/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/dataclass/classes/models.py b/test/driver_aiosqlite/dataclass/classes/models.py index a7fea135..605098f0 100644 --- a/test/driver_aiosqlite/dataclass/classes/models.py +++ b/test/driver_aiosqlite/dataclass/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/dataclass/classes/queries.py b/test/driver_aiosqlite/dataclass/classes/queries.py index 7fe5176e..60abe83a 100644 --- a/test/driver_aiosqlite/dataclass/classes/queries.py +++ b/test/driver_aiosqlite/dataclass/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/dataclass/functions/__init__.py b/test/driver_aiosqlite/dataclass/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/dataclass/functions/__init__.py +++ b/test/driver_aiosqlite/dataclass/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/dataclass/functions/models.py b/test/driver_aiosqlite/dataclass/functions/models.py index 104044c9..dd17e426 100644 --- a/test/driver_aiosqlite/dataclass/functions/models.py +++ b/test/driver_aiosqlite/dataclass/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/dataclass/functions/queries.py b/test/driver_aiosqlite/dataclass/functions/queries.py index c2ae430b..2b4258fd 100644 --- a/test/driver_aiosqlite/dataclass/functions/queries.py +++ b/test/driver_aiosqlite/dataclass/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/dataclass/functions/queries_slice.py b/test/driver_aiosqlite/dataclass/functions/queries_slice.py index ce2c6569..22197d81 100644 --- a/test/driver_aiosqlite/dataclass/functions/queries_slice.py +++ b/test/driver_aiosqlite/dataclass/functions/queries_slice.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_slice.sql """Module containing queries from file queries_slice.sql.""" diff --git a/test/driver_aiosqlite/msgspec/classes/__init__.py b/test/driver_aiosqlite/msgspec/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/msgspec/classes/__init__.py +++ b/test/driver_aiosqlite/msgspec/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/msgspec/classes/models.py b/test/driver_aiosqlite/msgspec/classes/models.py index 5a45d7e4..e40fa75c 100644 --- a/test/driver_aiosqlite/msgspec/classes/models.py +++ b/test/driver_aiosqlite/msgspec/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/msgspec/classes/queries.py b/test/driver_aiosqlite/msgspec/classes/queries.py index 50514597..f361a0e8 100644 --- a/test/driver_aiosqlite/msgspec/classes/queries.py +++ b/test/driver_aiosqlite/msgspec/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/msgspec/functions/__init__.py b/test/driver_aiosqlite/msgspec/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/msgspec/functions/__init__.py +++ b/test/driver_aiosqlite/msgspec/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/msgspec/functions/models.py b/test/driver_aiosqlite/msgspec/functions/models.py index 5a45d7e4..e40fa75c 100644 --- a/test/driver_aiosqlite/msgspec/functions/models.py +++ b/test/driver_aiosqlite/msgspec/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/msgspec/functions/queries.py b/test/driver_aiosqlite/msgspec/functions/queries.py index 4b5813f4..5d700e50 100644 --- a/test/driver_aiosqlite/msgspec/functions/queries.py +++ b/test/driver_aiosqlite/msgspec/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/pydantic/classes/__init__.py b/test/driver_aiosqlite/pydantic/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/pydantic/classes/__init__.py +++ b/test/driver_aiosqlite/pydantic/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/pydantic/classes/models.py b/test/driver_aiosqlite/pydantic/classes/models.py index 889f05ba..d7d1b7f0 100644 --- a/test/driver_aiosqlite/pydantic/classes/models.py +++ b/test/driver_aiosqlite/pydantic/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/pydantic/classes/queries.py b/test/driver_aiosqlite/pydantic/classes/queries.py index 59b5af3f..0de419d6 100644 --- a/test/driver_aiosqlite/pydantic/classes/queries.py +++ b/test/driver_aiosqlite/pydantic/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/pydantic/functions/__init__.py b/test/driver_aiosqlite/pydantic/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_aiosqlite/pydantic/functions/__init__.py +++ b/test/driver_aiosqlite/pydantic/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_aiosqlite/pydantic/functions/models.py b/test/driver_aiosqlite/pydantic/functions/models.py index 889f05ba..d7d1b7f0 100644 --- a/test/driver_aiosqlite/pydantic/functions/models.py +++ b/test/driver_aiosqlite/pydantic/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_aiosqlite/pydantic/functions/queries.py b/test/driver_aiosqlite/pydantic/functions/queries.py index bdd6d72a..0590b355 100644 --- a/test/driver_aiosqlite/pydantic/functions/queries.py +++ b/test/driver_aiosqlite/pydantic/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_aiosqlite/sqlc-gen-better-python.wasm b/test/driver_aiosqlite/sqlc-gen-better-python.wasm index 4e0b96b3..131a9b8e 100644 Binary files a/test/driver_aiosqlite/sqlc-gen-better-python.wasm and b/test/driver_aiosqlite/sqlc-gen-better-python.wasm differ diff --git a/test/driver_aiosqlite/sqlc.yaml b/test/driver_aiosqlite/sqlc.yaml index 0df85f39..0d2b6e02 100644 --- a/test/driver_aiosqlite/sqlc.yaml +++ b/test/driver_aiosqlite/sqlc.yaml @@ -3,7 +3,7 @@ plugins: - name: python wasm: url: file://sqlc-gen-better-python.wasm - sha256: 78698bcbf8188223f72f98228792f79a1e93dbaa20a6d41995e6eee962a3eb39 + sha256: 237081a0a5dfc42156c4cf1fd9b0d20fe8c4bcbbbcb9f9a18fb31f0151b9505e sql: - schema: schema.sql queries: queries.sql diff --git a/test/driver_asyncpg/attrs/classes/__init__.py b/test/driver_asyncpg/attrs/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/attrs/classes/__init__.py +++ b/test/driver_asyncpg/attrs/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/attrs/classes/enums.py b/test/driver_asyncpg/attrs/classes/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/attrs/classes/enums.py +++ b/test/driver_asyncpg/attrs/classes/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/attrs/classes/models.py b/test/driver_asyncpg/attrs/classes/models.py index 9000b5f2..be4141dc 100644 --- a/test/driver_asyncpg/attrs/classes/models.py +++ b/test/driver_asyncpg/attrs/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/attrs/classes/queries.py b/test/driver_asyncpg/attrs/classes/queries.py index ea02aa3f..cadb35d5 100644 --- a/test/driver_asyncpg/attrs/classes/queries.py +++ b/test/driver_asyncpg/attrs/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/attrs/classes/queries_copy_override.py b/test/driver_asyncpg/attrs/classes/queries_copy_override.py index c9e506e6..731d259f 100644 --- a/test/driver_asyncpg/attrs/classes/queries_copy_override.py +++ b/test/driver_asyncpg/attrs/classes/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/attrs/classes/queries_enum_override.py b/test/driver_asyncpg/attrs/classes/queries_enum_override.py index 027bf74f..b231fb94 100644 --- a/test/driver_asyncpg/attrs/classes/queries_enum_override.py +++ b/test/driver_asyncpg/attrs/classes/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/attrs/classes/queries_field_namings.py b/test/driver_asyncpg/attrs/classes/queries_field_namings.py index e9ea0ae4..ae02421b 100644 --- a/test/driver_asyncpg/attrs/classes/queries_field_namings.py +++ b/test/driver_asyncpg/attrs/classes/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/attrs/classes/queries_invalid_identifiers.py b/test/driver_asyncpg/attrs/classes/queries_invalid_identifiers.py index 5a897b89..0d01fa13 100644 --- a/test/driver_asyncpg/attrs/classes/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/attrs/classes/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/attrs/functions/__init__.py b/test/driver_asyncpg/attrs/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/attrs/functions/__init__.py +++ b/test/driver_asyncpg/attrs/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/attrs/functions/enums.py b/test/driver_asyncpg/attrs/functions/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/attrs/functions/enums.py +++ b/test/driver_asyncpg/attrs/functions/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/attrs/functions/models.py b/test/driver_asyncpg/attrs/functions/models.py index 4fab7fad..eb895c1c 100644 --- a/test/driver_asyncpg/attrs/functions/models.py +++ b/test/driver_asyncpg/attrs/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/attrs/functions/queries.py b/test/driver_asyncpg/attrs/functions/queries.py index 4b23e39a..7aa723d0 100644 --- a/test/driver_asyncpg/attrs/functions/queries.py +++ b/test/driver_asyncpg/attrs/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/attrs/functions/queries_copy_override.py b/test/driver_asyncpg/attrs/functions/queries_copy_override.py index 26576307..06ed01a8 100644 --- a/test/driver_asyncpg/attrs/functions/queries_copy_override.py +++ b/test/driver_asyncpg/attrs/functions/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/attrs/functions/queries_enum_override.py b/test/driver_asyncpg/attrs/functions/queries_enum_override.py index 4741e9a6..91488edd 100644 --- a/test/driver_asyncpg/attrs/functions/queries_enum_override.py +++ b/test/driver_asyncpg/attrs/functions/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/attrs/functions/queries_field_namings.py b/test/driver_asyncpg/attrs/functions/queries_field_namings.py index 72ffaffb..b0331a70 100644 --- a/test/driver_asyncpg/attrs/functions/queries_field_namings.py +++ b/test/driver_asyncpg/attrs/functions/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/attrs/functions/queries_invalid_identifiers.py b/test/driver_asyncpg/attrs/functions/queries_invalid_identifiers.py index 6dd2229e..ff7f9ce2 100644 --- a/test/driver_asyncpg/attrs/functions/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/attrs/functions/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/dataclass/classes/__init__.py b/test/driver_asyncpg/dataclass/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/dataclass/classes/__init__.py +++ b/test/driver_asyncpg/dataclass/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/dataclass/classes/enums.py b/test/driver_asyncpg/dataclass/classes/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/dataclass/classes/enums.py +++ b/test/driver_asyncpg/dataclass/classes/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/dataclass/classes/models.py b/test/driver_asyncpg/dataclass/classes/models.py index da198684..d84b90b7 100644 --- a/test/driver_asyncpg/dataclass/classes/models.py +++ b/test/driver_asyncpg/dataclass/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/dataclass/classes/queries.py b/test/driver_asyncpg/dataclass/classes/queries.py index cda28dfe..7796e8ab 100644 --- a/test/driver_asyncpg/dataclass/classes/queries.py +++ b/test/driver_asyncpg/dataclass/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/dataclass/classes/queries_copy_override.py b/test/driver_asyncpg/dataclass/classes/queries_copy_override.py index 7fe5fa0e..70f53ff7 100644 --- a/test/driver_asyncpg/dataclass/classes/queries_copy_override.py +++ b/test/driver_asyncpg/dataclass/classes/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/dataclass/classes/queries_enum_override.py b/test/driver_asyncpg/dataclass/classes/queries_enum_override.py index e49c457d..40ed81a1 100644 --- a/test/driver_asyncpg/dataclass/classes/queries_enum_override.py +++ b/test/driver_asyncpg/dataclass/classes/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/dataclass/classes/queries_field_namings.py b/test/driver_asyncpg/dataclass/classes/queries_field_namings.py index 88ad183f..76fe53d1 100644 --- a/test/driver_asyncpg/dataclass/classes/queries_field_namings.py +++ b/test/driver_asyncpg/dataclass/classes/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/dataclass/classes/queries_invalid_identifiers.py b/test/driver_asyncpg/dataclass/classes/queries_invalid_identifiers.py index f23c25e3..fbd441ab 100644 --- a/test/driver_asyncpg/dataclass/classes/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/dataclass/classes/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/dataclass/functions/__init__.py b/test/driver_asyncpg/dataclass/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/dataclass/functions/__init__.py +++ b/test/driver_asyncpg/dataclass/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/dataclass/functions/enums.py b/test/driver_asyncpg/dataclass/functions/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/dataclass/functions/enums.py +++ b/test/driver_asyncpg/dataclass/functions/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/dataclass/functions/models.py b/test/driver_asyncpg/dataclass/functions/models.py index 32798ec5..c5d54139 100644 --- a/test/driver_asyncpg/dataclass/functions/models.py +++ b/test/driver_asyncpg/dataclass/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/dataclass/functions/queries.py b/test/driver_asyncpg/dataclass/functions/queries.py index 3fba28d9..52723db6 100644 --- a/test/driver_asyncpg/dataclass/functions/queries.py +++ b/test/driver_asyncpg/dataclass/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/dataclass/functions/queries_converters.py b/test/driver_asyncpg/dataclass/functions/queries_converters.py index 2ffd9fc0..66d99b1a 100644 --- a/test/driver_asyncpg/dataclass/functions/queries_converters.py +++ b/test/driver_asyncpg/dataclass/functions/queries_converters.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_converters.sql """Module containing queries from file queries_converters.sql.""" diff --git a/test/driver_asyncpg/dataclass/functions/queries_copy_override.py b/test/driver_asyncpg/dataclass/functions/queries_copy_override.py index 2b6c4404..bfc527ef 100644 --- a/test/driver_asyncpg/dataclass/functions/queries_copy_override.py +++ b/test/driver_asyncpg/dataclass/functions/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/dataclass/functions/queries_enum_override.py b/test/driver_asyncpg/dataclass/functions/queries_enum_override.py index a1acd4a1..58fc75ee 100644 --- a/test/driver_asyncpg/dataclass/functions/queries_enum_override.py +++ b/test/driver_asyncpg/dataclass/functions/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/dataclass/functions/queries_field_namings.py b/test/driver_asyncpg/dataclass/functions/queries_field_namings.py index 0a7d63a4..351f884a 100644 --- a/test/driver_asyncpg/dataclass/functions/queries_field_namings.py +++ b/test/driver_asyncpg/dataclass/functions/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/dataclass/functions/queries_invalid_identifiers.py b/test/driver_asyncpg/dataclass/functions/queries_invalid_identifiers.py index 96d42daf..298cdc1e 100644 --- a/test/driver_asyncpg/dataclass/functions/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/dataclass/functions/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/msgspec/classes/__init__.py b/test/driver_asyncpg/msgspec/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/msgspec/classes/__init__.py +++ b/test/driver_asyncpg/msgspec/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/msgspec/classes/enums.py b/test/driver_asyncpg/msgspec/classes/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/msgspec/classes/enums.py +++ b/test/driver_asyncpg/msgspec/classes/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/msgspec/classes/models.py b/test/driver_asyncpg/msgspec/classes/models.py index 7abb090c..80c2d426 100644 --- a/test/driver_asyncpg/msgspec/classes/models.py +++ b/test/driver_asyncpg/msgspec/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/msgspec/classes/queries.py b/test/driver_asyncpg/msgspec/classes/queries.py index 99295323..8967fc10 100644 --- a/test/driver_asyncpg/msgspec/classes/queries.py +++ b/test/driver_asyncpg/msgspec/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/msgspec/classes/queries_copy_override.py b/test/driver_asyncpg/msgspec/classes/queries_copy_override.py index 6bb006e1..0d037407 100644 --- a/test/driver_asyncpg/msgspec/classes/queries_copy_override.py +++ b/test/driver_asyncpg/msgspec/classes/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/msgspec/classes/queries_enum_override.py b/test/driver_asyncpg/msgspec/classes/queries_enum_override.py index 85a5840f..309e2862 100644 --- a/test/driver_asyncpg/msgspec/classes/queries_enum_override.py +++ b/test/driver_asyncpg/msgspec/classes/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/msgspec/classes/queries_field_namings.py b/test/driver_asyncpg/msgspec/classes/queries_field_namings.py index 359b0613..1a8657e8 100644 --- a/test/driver_asyncpg/msgspec/classes/queries_field_namings.py +++ b/test/driver_asyncpg/msgspec/classes/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/msgspec/classes/queries_invalid_identifiers.py b/test/driver_asyncpg/msgspec/classes/queries_invalid_identifiers.py index ff607176..80d19442 100644 --- a/test/driver_asyncpg/msgspec/classes/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/msgspec/classes/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/msgspec/functions/__init__.py b/test/driver_asyncpg/msgspec/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/msgspec/functions/__init__.py +++ b/test/driver_asyncpg/msgspec/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/msgspec/functions/enums.py b/test/driver_asyncpg/msgspec/functions/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/msgspec/functions/enums.py +++ b/test/driver_asyncpg/msgspec/functions/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/msgspec/functions/models.py b/test/driver_asyncpg/msgspec/functions/models.py index 9379a1d9..849411cd 100644 --- a/test/driver_asyncpg/msgspec/functions/models.py +++ b/test/driver_asyncpg/msgspec/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/msgspec/functions/queries.py b/test/driver_asyncpg/msgspec/functions/queries.py index efa61df6..0c135e5b 100644 --- a/test/driver_asyncpg/msgspec/functions/queries.py +++ b/test/driver_asyncpg/msgspec/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/msgspec/functions/queries_copy_override.py b/test/driver_asyncpg/msgspec/functions/queries_copy_override.py index 0c1d651d..3fce60de 100644 --- a/test/driver_asyncpg/msgspec/functions/queries_copy_override.py +++ b/test/driver_asyncpg/msgspec/functions/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/msgspec/functions/queries_enum_override.py b/test/driver_asyncpg/msgspec/functions/queries_enum_override.py index ee233fb7..44568c2f 100644 --- a/test/driver_asyncpg/msgspec/functions/queries_enum_override.py +++ b/test/driver_asyncpg/msgspec/functions/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/msgspec/functions/queries_field_namings.py b/test/driver_asyncpg/msgspec/functions/queries_field_namings.py index 1a440819..9487f056 100644 --- a/test/driver_asyncpg/msgspec/functions/queries_field_namings.py +++ b/test/driver_asyncpg/msgspec/functions/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/msgspec/functions/queries_invalid_identifiers.py b/test/driver_asyncpg/msgspec/functions/queries_invalid_identifiers.py index 91e6a57f..224faa3e 100644 --- a/test/driver_asyncpg/msgspec/functions/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/msgspec/functions/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/omit_tc/classes/__init__.py b/test/driver_asyncpg/omit_tc/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/omit_tc/classes/__init__.py +++ b/test/driver_asyncpg/omit_tc/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/omit_tc/classes/enums.py b/test/driver_asyncpg/omit_tc/classes/enums.py index 59f703f3..0cfc74ec 100644 --- a/test/driver_asyncpg/omit_tc/classes/enums.py +++ b/test/driver_asyncpg/omit_tc/classes/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/omit_tc/classes/models.py b/test/driver_asyncpg/omit_tc/classes/models.py index 002e27b1..62c9ced9 100644 --- a/test/driver_asyncpg/omit_tc/classes/models.py +++ b/test/driver_asyncpg/omit_tc/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/omit_tc/classes/queries_enum_override.py b/test/driver_asyncpg/omit_tc/classes/queries_enum_override.py index 975a2215..b3bbc81a 100644 --- a/test/driver_asyncpg/omit_tc/classes/queries_enum_override.py +++ b/test/driver_asyncpg/omit_tc/classes/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/omit_tc/functions/__init__.py b/test/driver_asyncpg/omit_tc/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/omit_tc/functions/__init__.py +++ b/test/driver_asyncpg/omit_tc/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/omit_tc/functions/enums.py b/test/driver_asyncpg/omit_tc/functions/enums.py index 59f703f3..0cfc74ec 100644 --- a/test/driver_asyncpg/omit_tc/functions/enums.py +++ b/test/driver_asyncpg/omit_tc/functions/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/omit_tc/functions/models.py b/test/driver_asyncpg/omit_tc/functions/models.py index 002e27b1..62c9ced9 100644 --- a/test/driver_asyncpg/omit_tc/functions/models.py +++ b/test/driver_asyncpg/omit_tc/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/omit_tc/functions/queries_enum_override.py b/test/driver_asyncpg/omit_tc/functions/queries_enum_override.py index 9763965a..a83289b6 100644 --- a/test/driver_asyncpg/omit_tc/functions/queries_enum_override.py +++ b/test/driver_asyncpg/omit_tc/functions/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/pydantic/classes/__init__.py b/test/driver_asyncpg/pydantic/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/pydantic/classes/__init__.py +++ b/test/driver_asyncpg/pydantic/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/pydantic/classes/enums.py b/test/driver_asyncpg/pydantic/classes/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/pydantic/classes/enums.py +++ b/test/driver_asyncpg/pydantic/classes/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/pydantic/classes/models.py b/test/driver_asyncpg/pydantic/classes/models.py index 18d0aeab..4c24a805 100644 --- a/test/driver_asyncpg/pydantic/classes/models.py +++ b/test/driver_asyncpg/pydantic/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/pydantic/classes/queries.py b/test/driver_asyncpg/pydantic/classes/queries.py index 003faef9..8a8d9aaf 100644 --- a/test/driver_asyncpg/pydantic/classes/queries.py +++ b/test/driver_asyncpg/pydantic/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/pydantic/classes/queries_copy_override.py b/test/driver_asyncpg/pydantic/classes/queries_copy_override.py index c9bedf3f..dda5445e 100644 --- a/test/driver_asyncpg/pydantic/classes/queries_copy_override.py +++ b/test/driver_asyncpg/pydantic/classes/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/pydantic/classes/queries_enum_override.py b/test/driver_asyncpg/pydantic/classes/queries_enum_override.py index 0d39a30c..7e77a48b 100644 --- a/test/driver_asyncpg/pydantic/classes/queries_enum_override.py +++ b/test/driver_asyncpg/pydantic/classes/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/pydantic/classes/queries_field_namings.py b/test/driver_asyncpg/pydantic/classes/queries_field_namings.py index 35713583..07e17a2c 100644 --- a/test/driver_asyncpg/pydantic/classes/queries_field_namings.py +++ b/test/driver_asyncpg/pydantic/classes/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/pydantic/classes/queries_invalid_identifiers.py b/test/driver_asyncpg/pydantic/classes/queries_invalid_identifiers.py index 76ef04a1..a5273c79 100644 --- a/test/driver_asyncpg/pydantic/classes/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/pydantic/classes/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/pydantic/functions/__init__.py b/test/driver_asyncpg/pydantic/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_asyncpg/pydantic/functions/__init__.py +++ b/test/driver_asyncpg/pydantic/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_asyncpg/pydantic/functions/enums.py b/test/driver_asyncpg/pydantic/functions/enums.py index 84fd722e..734b78b6 100644 --- a/test/driver_asyncpg/pydantic/functions/enums.py +++ b/test/driver_asyncpg/pydantic/functions/enums.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing enums.""" from __future__ import annotations diff --git a/test/driver_asyncpg/pydantic/functions/models.py b/test/driver_asyncpg/pydantic/functions/models.py index d918bd0d..f1ef4135 100644 --- a/test/driver_asyncpg/pydantic/functions/models.py +++ b/test/driver_asyncpg/pydantic/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_asyncpg/pydantic/functions/queries.py b/test/driver_asyncpg/pydantic/functions/queries.py index f59d0bc3..c3dacaae 100644 --- a/test/driver_asyncpg/pydantic/functions/queries.py +++ b/test/driver_asyncpg/pydantic/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_asyncpg/pydantic/functions/queries_copy_override.py b/test/driver_asyncpg/pydantic/functions/queries_copy_override.py index 0a4c6bab..a50f122d 100644 --- a/test/driver_asyncpg/pydantic/functions/queries_copy_override.py +++ b/test/driver_asyncpg/pydantic/functions/queries_copy_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_copy_override.sql """Module containing queries from file queries_copy_override.sql.""" diff --git a/test/driver_asyncpg/pydantic/functions/queries_enum_override.py b/test/driver_asyncpg/pydantic/functions/queries_enum_override.py index b9f25e8a..75ce735d 100644 --- a/test/driver_asyncpg/pydantic/functions/queries_enum_override.py +++ b/test/driver_asyncpg/pydantic/functions/queries_enum_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_enum_override.sql """Module containing queries from file queries_enum_override.sql.""" diff --git a/test/driver_asyncpg/pydantic/functions/queries_field_namings.py b/test/driver_asyncpg/pydantic/functions/queries_field_namings.py index d2d85907..004a5f81 100644 --- a/test/driver_asyncpg/pydantic/functions/queries_field_namings.py +++ b/test/driver_asyncpg/pydantic/functions/queries_field_namings.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_field_namings.sql """Module containing queries from file queries_field_namings.sql.""" diff --git a/test/driver_asyncpg/pydantic/functions/queries_invalid_identifiers.py b/test/driver_asyncpg/pydantic/functions/queries_invalid_identifiers.py index 4f57d483..bf51c6c6 100644 --- a/test/driver_asyncpg/pydantic/functions/queries_invalid_identifiers.py +++ b/test/driver_asyncpg/pydantic/functions/queries_invalid_identifiers.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_invalid_identifiers.sql """Module containing queries from file queries_invalid_identifiers.sql.""" diff --git a/test/driver_asyncpg/sqlc-gen-better-python.wasm b/test/driver_asyncpg/sqlc-gen-better-python.wasm index 4e0b96b3..131a9b8e 100644 Binary files a/test/driver_asyncpg/sqlc-gen-better-python.wasm and b/test/driver_asyncpg/sqlc-gen-better-python.wasm differ diff --git a/test/driver_asyncpg/sqlc.yaml b/test/driver_asyncpg/sqlc.yaml index 6bfd8098..e618d710 100644 --- a/test/driver_asyncpg/sqlc.yaml +++ b/test/driver_asyncpg/sqlc.yaml @@ -3,7 +3,7 @@ plugins: - name: python wasm: url: file://sqlc-gen-better-python.wasm - sha256: 78698bcbf8188223f72f98228792f79a1e93dbaa20a6d41995e6eee962a3eb39 + sha256: 237081a0a5dfc42156c4cf1fd9b0d20fe8c4bcbbbcb9f9a18fb31f0151b9505e sql: - schema: schema.sql queries: diff --git a/test/driver_psycopg_async/__init__.py b/test/driver_psycopg_async/__init__.py new file mode 100644 index 00000000..242b9d5f --- /dev/null +++ b/test/driver_psycopg_async/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""Package to allow importing for psycopg tests.""" diff --git a/test/driver_psycopg_async/attrs/__init__.py b/test/driver_psycopg_async/attrs/__init__.py new file mode 100644 index 00000000..242b9d5f --- /dev/null +++ b/test/driver_psycopg_async/attrs/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""Package to allow importing for psycopg tests.""" diff --git a/test/driver_psycopg_async/attrs/classes/__init__.py b/test/driver_psycopg_async/attrs/classes/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/attrs/classes/enums.py b/test/driver_psycopg_async/attrs/classes/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/attrs/classes/models.py b/test/driver_psycopg_async/attrs/classes/models.py new file mode 100644 index 00000000..134f3bdd --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/models.py @@ -0,0 +1,291 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +import attrs +import typing + +if typing.TYPE_CHECKING: + from collections import UserString + from test.driver_psycopg_async.attrs.classes import enums + import collections.abc + import datetime + import decimal + import uuid + + +@attrs.define() +class Model3RdPartyStat: + """Model representing Model3RdPartyStat. + + Attributes + ---------- + id_ : int + total : int + + """ + + id_: int + total: int + + +@attrs.define() +class TestEnumOverride: + """Model representing TestEnumOverride. + + Attributes + ---------- + id_ : int + mood_test : str + + """ + + id_: int + mood_test: str + + +@attrs.define() +class TestEnumType: + """Model representing TestEnumType. + + Attributes + ---------- + id_ : int + mood : enums.TestMood + maybe_mood : enums.TestMood | None + + """ + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +@attrs.define() +class TestFieldNaming: + """Model representing TestFieldNaming. + + Attributes + ---------- + id_ : int + outputs : str + + """ + + id_: int + outputs: str + + +@attrs.define() +class TestInnerPostgresType: + """Model representing TestInnerPostgresType. + + Attributes + ---------- + table_id : int + serial_test : int | None + serial4_test : int | None + bigserial_test : int | None + smallserial_test : int | None + int_test : int | None + bigint_test : int | None + smallint_test : int | None + float_test : float | None + double_precision_test : float | None + real_test : float | None + numeric_test : decimal.Decimal | None + money_test : str | None + bool_test : bool | None + json_test : str | None + jsonb_test : str | None + bytea_test : memoryview | None + date_test : datetime.date | None + time_test : datetime.time | None + timetz_test : datetime.time | None + timestamp_test : datetime.datetime | None + timestamptz_test : datetime.datetime | None + interval_test : datetime.timedelta | None + text_test : str | None + varchar_test : str | None + bpchar_test : str | None + char_test : str | None + citext_test : str | None + uuid_test : uuid.UUID | None + inet_test : str | None + cidr_test : str | None + macaddr_test : str | None + macaddr8_test : str | None + ltree_test : str | None + lquery_test : str | None + ltxtquery_test : str | None + + """ + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +@attrs.define() +class TestInvalidIdentifier: + """Model representing TestInvalidIdentifier. + + Attributes + ---------- + id_ : int + column_3p_ : str | None + new_notes : str + column__pct : str | None + + """ + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +@attrs.define() +class TestPostgresType: + """Model representing TestPostgresType. + + Attributes + ---------- + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +@attrs.define() +class TestTypeOverride: + """Model representing TestTypeOverride. + + Attributes + ---------- + id_ : int + text_test : UserString | None + + """ + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/attrs/classes/queries.py b/test/driver_psycopg_async/attrs/classes/queries.py new file mode 100644 index 00000000..939dd223 --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/queries.py @@ -0,0 +1,2223 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "Queries", + "QueryResults", + "TestCopyFromParams", +) + +from collections import UserString +import attrs +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import datetime + import decimal + import uuid + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.classes import enums +from test.driver_psycopg_async.attrs.classes import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@attrs.define() +class GetEmbeddedTestPostgresTypeRow: + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes + ---------- + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + test_inner_postgres_type : models.TestInnerPostgresType + + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +@attrs.define() +class GetAllEmbeddedTestPostgresTypeRow: + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes + ---------- + test_postgres_type : models.TestPostgresType + test_inner_postgres_type : models.TestInnerPostgresType + + """ + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +@attrs.define() +class TestCopyFromParams: + """Model representing TestCopyFromParams. + + Attributes + ---------- + id_ : int + float_test : float + int_test : int + + """ + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db. + + Parameters + ---------- + conn + The connection object of type `ConnectionLike` used to execute queries. + sql + The SQL statement that will be executed when fetching/iterating. + decode_hook + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params + Named arguments that should be sent when executing the sql query. + + """ + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance.""" + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns + ------- + QueryResults[T] + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopAsyncIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class Queries: + """Queries from file queries.sql. + + Parameters + ---------- + conn : ConnectionLike + The connection object used to execute queries. + + """ + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection.""" + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns + ------- + ConnectionLike + + """ + return self._conn + + async def get_one_test_postgres_type(self, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + models.TestPostgresType + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_inner_test_postgres_type(self, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + table_id : int + + Returns + ------- + models.TestInnerPostgresType + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_test_timestamp_postgres_type(self, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + datetime.datetime + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + async def get_one_test_bytea_postgres_type(self, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + memoryview + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + def get_many_test_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + QueryResults[models.TestPostgresType] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_iterator_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + QueryResults[models.TestPostgresType] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_timestamp_postgres_type(self, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + QueryResults[datetime.datetime] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + return QueryResults(self._conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + def get_many_test_bytea_postgres_type(self, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + QueryResults[memoryview] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(self._conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + async def get_embedded_test_postgres_type(self, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + GetEmbeddedTestPostgresTypeRow + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def get_all_embedded_test_postgres_type(self, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + GetAllEmbeddedTestPostgresTypeRow + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def create_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def create_one_test_postgres_inner_type( + self, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + table_id : int + serial_test : int | None + serial4_test : int | None + bigserial_test : int | None + smallserial_test : int | None + int_test : int | None + bigint_test : int | None + smallint_test : int | None + float_test : float | None + double_precision_test : float | None + real_test : float | None + numeric_test : decimal.Decimal | None + money_test : str | None + bool_test : bool | None + json_test : str | None + jsonb_test : str | None + bytea_test : memoryview | None + date_test : datetime.date | None + time_test : datetime.time | None + timetz_test : datetime.time | None + timestamp_test : datetime.datetime | None + timestamptz_test : datetime.datetime | None + interval_test : datetime.timedelta | None + text_test : str | None + varchar_test : str | None + bpchar_test : str | None + char_test : str | None + citext_test : str | None + uuid_test : uuid.UUID | None + inet_test : str | None + cidr_test : str | None + macaddr_test : str | None + macaddr8_test : str | None + ltree_test : str | None + lquery_test : str | None + ltxtquery_test : str | None + + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + async def delete_one_test_postgres_type(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_test_postgres_inner_type(self, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Parameters + ---------- + table_id : int + + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + async def create_result_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + Returns + ------- + psycopg.AsyncCursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def update_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + psycopg.AsyncCursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return await self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + psycopg.AsyncCursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return await self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def create_rows_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + async def update_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def delete_one_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def create_rows_table(self) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + async def test_copy_from(self, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Parameters + ---------- + params : collections.abc.Sequence[TestCopyFromParams] + A list of params for rows that should be inserted. + + Returns + ------- + int + The number of affected rows. + + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + async def insert_type_override(self, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Parameters + ---------- + id_ : int + text_test : UserString | None + + """ + await self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + async def get_one_type_override(self, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + models.TestTypeOverride + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + def get_many_type_override(self, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + QueryResults[models.TestTypeOverride] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(self._conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def get_one_text_type_override(self, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + UserString + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + def get_many_text_type_override(self, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + QueryResults[UserString | None] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(self._conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def delete_type_override(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + """ + await self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + async def insert_one_test_enum_type(self, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Parameters + ---------- + id_ : int + mood : enums.TestMood + maybe_mood : enums.TestMood | None + + """ + await self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + async def get_one_test_enum_type(self, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + models.TestEnumType + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + async def get_one_test_enum_value(self, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + enums.TestMood + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + def get_many_test_enum_types(self) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Returns + ------- + QueryResults[models.TestEnumType] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(self._conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + async def delete_one_test_enum_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/attrs/classes/queries_copy_override.py b/test/driver_psycopg_async/attrs/classes/queries_copy_override.py new file mode 100644 index 00000000..704533a1 --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/queries_copy_override.py @@ -0,0 +1,130 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "QueriesCopyOverride", +) + +import attrs +import decimal +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +@attrs.define() +class CopyOverrideRowsParams: + """Model representing CopyOverrideRowsParams. + + Attributes + ---------- + id_ : int + amount : float + co_l : str + + """ + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +class QueriesCopyOverride: + """Queries from file queries_copy_override.sql. + + Parameters + ---------- + conn : ConnectionLike + The connection object used to execute queries. + + """ + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection.""" + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns + ------- + ConnectionLike + + """ + return self._conn + + async def copy_override_rows(self, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Parameters + ---------- + params : collections.abc.Sequence[CopyOverrideRowsParams] + A list of params for rows that should be inserted. + + Returns + ------- + int + The number of affected rows. + + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + async def count_copy_override_rows(self) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Returns + ------- + int + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + async def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + await self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/attrs/classes/queries_enum_override.py b/test/driver_psycopg_async/attrs/classes/queries_enum_override.py new file mode 100644 index 00000000..0e98469c --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/queries_enum_override.py @@ -0,0 +1,239 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueriesEnumOverride", + "QueryResults", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.classes import enums +from test.driver_psycopg_async.attrs.classes import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db. + + Parameters + ---------- + conn + The connection object of type `ConnectionLike` used to execute queries. + sql + The SQL statement that will be executed when fetching/iterating. + decode_hook + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params + Named arguments that should be sent when executing the sql query. + + """ + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance.""" + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns + ------- + QueryResults[T] + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopAsyncIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class QueriesEnumOverride: + """Queries from file queries_enum_override.sql. + + Parameters + ---------- + conn : ConnectionLike + The connection object used to execute queries. + + """ + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection.""" + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns + ------- + ConnectionLike + + """ + return self._conn + + async def insert_enum_override(self, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Parameters + ---------- + id_ : int + mood_test : str + + """ + await self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + async def get_enum_override_mood(self, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + str + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + def list_enum_override_by_ids(self, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Parameters + ---------- + dollar_1 : collections.abc.Sequence[int] + + Returns + ------- + QueryResults[models.TestEnumOverride] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(self._conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + async def count_enum_override_by_moods(self, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Parameters + ---------- + dollar_1 : collections.abc.Sequence[enums.TestMood] + + Returns + ------- + int + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/attrs/classes/queries_field_namings.py b/test/driver_psycopg_async/attrs/classes/queries_field_namings.py new file mode 100644 index 00000000..edd122ff --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/queries_field_namings.py @@ -0,0 +1,159 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "QueriesFieldNamings", +) + +import attrs +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.classes import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@attrs.define() +class GetJoinedFieldNamingsRow: + """Model representing GetJoinedFieldNamingsRow. + + Attributes + ---------- + outputs : str + outputs_2 : str + + """ + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +class QueriesFieldNamings: + """Queries from file queries_field_namings.sql. + + Parameters + ---------- + conn : ConnectionLike + The connection object used to execute queries. + + """ + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection.""" + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns + ------- + ConnectionLike + + """ + return self._conn + + async def get_field_naming(self, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + models.TestFieldNaming + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + async def get_joined_field_namings(self, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + GetJoinedFieldNamingsRow + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + async def set_field_naming_outputs(self, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Parameters + ---------- + id_ : int + outputs : str + outputs_2 : str + + """ + await self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/attrs/classes/queries_invalid_identifiers.py b/test/driver_psycopg_async/attrs/classes/queries_invalid_identifiers.py new file mode 100644 index 00000000..19b15162 --- /dev/null +++ b/test/driver_psycopg_async/attrs/classes/queries_invalid_identifiers.py @@ -0,0 +1,141 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("QueriesInvalidIdentifiers",) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.classes import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +class QueriesInvalidIdentifiers: + """Queries from file queries_invalid_identifiers.sql. + + Parameters + ---------- + conn : ConnectionLike + The connection object used to execute queries. + + """ + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection.""" + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns + ------- + ConnectionLike + + """ + return self._conn + + async def insert_invalid_identifiers(self, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Parameters + ---------- + id_ : int + column_3p_ : str | None + new_notes : str + + """ + await self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + async def get_invalid_identifiers(self, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + models.TestInvalidIdentifier + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + async def insert_third_party_stat(self, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Parameters + ---------- + id_ : int + total : int + + """ + await self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + async def get_third_party_stat(self, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Parameters + ---------- + id_ : int + + Returns + ------- + models.Model3RdPartyStat + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await self._conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/attrs/functions/__init__.py b/test/driver_psycopg_async/attrs/functions/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/attrs/functions/enums.py b/test/driver_psycopg_async/attrs/functions/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/attrs/functions/models.py b/test/driver_psycopg_async/attrs/functions/models.py new file mode 100644 index 00000000..3aaa9c8b --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/models.py @@ -0,0 +1,291 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +import attrs +import typing + +if typing.TYPE_CHECKING: + from collections import UserString + from test.driver_psycopg_async.attrs.functions import enums + import collections.abc + import datetime + import decimal + import uuid + + +@attrs.define() +class Model3RdPartyStat: + """Model representing Model3RdPartyStat. + + Attributes + ---------- + id_ : int + total : int + + """ + + id_: int + total: int + + +@attrs.define() +class TestEnumOverride: + """Model representing TestEnumOverride. + + Attributes + ---------- + id_ : int + mood_test : str + + """ + + id_: int + mood_test: str + + +@attrs.define() +class TestEnumType: + """Model representing TestEnumType. + + Attributes + ---------- + id_ : int + mood : enums.TestMood + maybe_mood : enums.TestMood | None + + """ + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +@attrs.define() +class TestFieldNaming: + """Model representing TestFieldNaming. + + Attributes + ---------- + id_ : int + outputs : str + + """ + + id_: int + outputs: str + + +@attrs.define() +class TestInnerPostgresType: + """Model representing TestInnerPostgresType. + + Attributes + ---------- + table_id : int + serial_test : int | None + serial4_test : int | None + bigserial_test : int | None + smallserial_test : int | None + int_test : int | None + bigint_test : int | None + smallint_test : int | None + float_test : float | None + double_precision_test : float | None + real_test : float | None + numeric_test : decimal.Decimal | None + money_test : str | None + bool_test : bool | None + json_test : str | None + jsonb_test : str | None + bytea_test : memoryview | None + date_test : datetime.date | None + time_test : datetime.time | None + timetz_test : datetime.time | None + timestamp_test : datetime.datetime | None + timestamptz_test : datetime.datetime | None + interval_test : datetime.timedelta | None + text_test : str | None + varchar_test : str | None + bpchar_test : str | None + char_test : str | None + citext_test : str | None + uuid_test : uuid.UUID | None + inet_test : str | None + cidr_test : str | None + macaddr_test : str | None + macaddr8_test : str | None + ltree_test : str | None + lquery_test : str | None + ltxtquery_test : str | None + + """ + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +@attrs.define() +class TestInvalidIdentifier: + """Model representing TestInvalidIdentifier. + + Attributes + ---------- + id_ : int + column_3p_ : str | None + new_notes : str + column__pct : str | None + + """ + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +@attrs.define() +class TestPostgresType: + """Model representing TestPostgresType. + + Attributes + ---------- + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +@attrs.define() +class TestTypeOverride: + """Model representing TestTypeOverride. + + Attributes + ---------- + id_ : int + text_test : UserString | None + + """ + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/attrs/functions/queries.py b/test/driver_psycopg_async/attrs/functions/queries.py new file mode 100644 index 00000000..58e9a1cc --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/queries.py @@ -0,0 +1,2332 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "QueryResults", + "TestCopyFromParams", + "create_one_test_postgres_inner_type", + "create_one_test_postgres_type", + "create_result_one_test_postgres_type", + "create_rows_one_test_postgres_type", + "create_rows_table", + "delete_one_result_test_postgres_type", + "delete_one_rows_test_postgres_type", + "delete_one_test_enum_type", + "delete_one_test_postgres_inner_type", + "delete_one_test_postgres_type", + "delete_type_override", + "get_all_embedded_test_postgres_type", + "get_embedded_test_postgres_type", + "get_many_test_bytea_postgres_type", + "get_many_test_enum_types", + "get_many_test_iterator_postgres_type", + "get_many_test_postgres_type", + "get_many_test_timestamp_postgres_type", + "get_many_text_type_override", + "get_many_type_override", + "get_one_inner_test_postgres_type", + "get_one_test_bytea_postgres_type", + "get_one_test_enum_type", + "get_one_test_enum_value", + "get_one_test_postgres_type", + "get_one_test_timestamp_postgres_type", + "get_one_text_type_override", + "get_one_type_override", + "insert_one_test_enum_type", + "insert_type_override", + "test_copy_from", + "update_result_test_postgres_type", + "update_rows_test_postgres_type", +) + +from collections import UserString +import attrs +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import datetime + import decimal + import uuid + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.functions import enums +from test.driver_psycopg_async.attrs.functions import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@attrs.define() +class GetEmbeddedTestPostgresTypeRow: + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes + ---------- + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + test_inner_postgres_type : models.TestInnerPostgresType + + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +@attrs.define() +class GetAllEmbeddedTestPostgresTypeRow: + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes + ---------- + test_postgres_type : models.TestPostgresType + test_inner_postgres_type : models.TestInnerPostgresType + + """ + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +@attrs.define() +class TestCopyFromParams: + """Model representing TestCopyFromParams. + + Attributes + ---------- + id_ : int + float_test : float + int_test : int + + """ + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db. + + Parameters + ---------- + conn + The connection object of type `ConnectionLike` used to execute queries. + sql + The SQL statement that will be executed when fetching/iterating. + decode_hook + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params + Named arguments that should be sent when executing the sql query. + + """ + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance.""" + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns + ------- + QueryResults[T] + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopAsyncIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def get_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + models.TestPostgresType + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_inner_test_postgres_type(conn: ConnectionLike, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + table_id : int + + Returns + ------- + models.TestInnerPostgresType + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + datetime.datetime + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + +async def get_one_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + memoryview + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + +def get_many_test_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + QueryResults[models.TestPostgresType] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_iterator_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + QueryResults[models.TestPostgresType] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + QueryResults[datetime.datetime] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + return QueryResults(conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + +def get_many_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + QueryResults[memoryview] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +async def get_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + GetEmbeddedTestPostgresTypeRow + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def get_all_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + GetAllEmbeddedTestPostgresTypeRow + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def create_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def create_one_test_postgres_inner_type( + conn: ConnectionLike, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + table_id : int + serial_test : int | None + serial4_test : int | None + bigserial_test : int | None + smallserial_test : int | None + int_test : int | None + bigint_test : int | None + smallint_test : int | None + float_test : float | None + double_precision_test : float | None + real_test : float | None + numeric_test : decimal.Decimal | None + money_test : str | None + bool_test : bool | None + json_test : str | None + jsonb_test : str | None + bytea_test : memoryview | None + date_test : datetime.date | None + time_test : datetime.time | None + timetz_test : datetime.time | None + timestamp_test : datetime.datetime | None + timestamptz_test : datetime.datetime | None + interval_test : datetime.timedelta | None + text_test : str | None + varchar_test : str | None + bpchar_test : str | None + char_test : str | None + citext_test : str | None + uuid_test : uuid.UUID | None + inet_test : str | None + cidr_test : str | None + macaddr_test : str | None + macaddr8_test : str | None + ltree_test : str | None + lquery_test : str | None + ltxtquery_test : str | None + + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +async def delete_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_test_postgres_inner_type(conn: ConnectionLike, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + table_id : int + + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +async def create_result_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + Returns + ------- + psycopg.AsyncCursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + psycopg.AsyncCursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return await conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + psycopg.AsyncCursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return await conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def create_rows_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + serial_test : int + serial4_test : int + bigserial_test : int + smallserial_test : int + int_test : int + bigint_test : int + smallint_test : int + float_test : float + double_precision_test : float + real_test : float + numeric_test : decimal.Decimal + money_test : str + bool_test : bool + json_test : str + jsonb_test : str + bytea_test : memoryview + date_test : datetime.date + time_test : datetime.time + timetz_test : datetime.time + timestamp_test : datetime.datetime + timestamptz_test : datetime.datetime + interval_test : datetime.timedelta + text_test : str + varchar_test : str + bpchar_test : str + char_test : str + citext_test : str + uuid_test : uuid.UUID + inet_test : str + cidr_test : str + macaddr_test : str + macaddr8_test : str + ltree_test : str + lquery_test : str + ltxtquery_test : str + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +async def update_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def delete_one_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def create_rows_table(conn: ConnectionLike) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + params : collections.abc.Sequence[TestCopyFromParams] + A list of params for rows that should be inserted. + + Returns + ------- + int + The number of affected rows. + + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +async def insert_type_override(conn: ConnectionLike, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + text_test : UserString | None + + """ + await conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +async def get_one_type_override(conn: ConnectionLike, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + models.TestTypeOverride + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + +def get_many_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + QueryResults[models.TestTypeOverride] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def get_one_text_type_override(conn: ConnectionLike, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + UserString + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + +def get_many_text_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + QueryResults[UserString | None] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def delete_type_override(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + """ + await conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +async def insert_one_test_enum_type(conn: ConnectionLike, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + mood : enums.TestMood + maybe_mood : enums.TestMood | None + + """ + await conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +async def get_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + models.TestEnumType + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + +async def get_one_test_enum_value(conn: ConnectionLike, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + enums.TestMood + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + +def get_many_test_enum_types(conn: ConnectionLike) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + + Returns + ------- + QueryResults[models.TestEnumType] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + +async def delete_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + int + The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + + """ + cur = await conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/attrs/functions/queries_copy_override.py b/test/driver_psycopg_async/attrs/functions/queries_copy_override.py new file mode 100644 index 00000000..b82abb8a --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/queries_copy_override.py @@ -0,0 +1,119 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "copy_override_rows", + "count_copy_override_rows", + "delete_copy_override_rows", +) + +import attrs +import decimal +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +@attrs.define() +class CopyOverrideRowsParams: + """Model representing CopyOverrideRowsParams. + + Attributes + ---------- + id_ : int + amount : float + co_l : str + + """ + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +async def copy_override_rows(conn: ConnectionLike, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + params : collections.abc.Sequence[CopyOverrideRowsParams] + A list of params for rows that should be inserted. + + Returns + ------- + int + The number of affected rows. + + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +async def count_copy_override_rows(conn: ConnectionLike) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + + Returns + ------- + int + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + +async def delete_copy_override_rows(conn: ConnectionLike) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + + """ + await conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/attrs/functions/queries_enum_override.py b/test/driver_psycopg_async/attrs/functions/queries_enum_override.py new file mode 100644 index 00000000..5c39e6c9 --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/queries_enum_override.py @@ -0,0 +1,226 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueryResults", + "count_enum_override_by_moods", + "get_enum_override_mood", + "insert_enum_override", + "list_enum_override_by_ids", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.functions import enums +from test.driver_psycopg_async.attrs.functions import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db. + + Parameters + ---------- + conn + The connection object of type `ConnectionLike` used to execute queries. + sql + The SQL statement that will be executed when fetching/iterating. + decode_hook + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params + Named arguments that should be sent when executing the sql query. + + """ + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance.""" + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns + ------- + QueryResults[T] + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopAsyncIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def insert_enum_override(conn: ConnectionLike, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + mood_test : str + + """ + await conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +async def get_enum_override_mood(conn: ConnectionLike, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + str + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + +def list_enum_override_by_ids(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + dollar_1 : collections.abc.Sequence[int] + + Returns + ------- + QueryResults[models.TestEnumOverride] + Helper class that allows both iteration and normal fetching of data from the db. + + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + +async def count_enum_override_by_moods(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + dollar_1 : collections.abc.Sequence[enums.TestMood] + + Returns + ------- + int + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/attrs/functions/queries_field_namings.py b/test/driver_psycopg_async/attrs/functions/queries_field_namings.py new file mode 100644 index 00000000..879e6672 --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/queries_field_namings.py @@ -0,0 +1,142 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "get_field_naming", + "get_joined_field_namings", + "set_field_naming_outputs", +) + +import attrs +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.functions import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@attrs.define() +class GetJoinedFieldNamingsRow: + """Model representing GetJoinedFieldNamingsRow. + + Attributes + ---------- + outputs : str + outputs_2 : str + + """ + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +async def get_field_naming(conn: ConnectionLike, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + models.TestFieldNaming + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +async def get_joined_field_namings(conn: ConnectionLike, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + GetJoinedFieldNamingsRow + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +async def set_field_naming_outputs(conn: ConnectionLike, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + outputs : str + outputs_2 : str + + """ + await conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/attrs/functions/queries_invalid_identifiers.py b/test/driver_psycopg_async/attrs/functions/queries_invalid_identifiers.py new file mode 100644 index 00000000..306df244 --- /dev/null +++ b/test/driver_psycopg_async/attrs/functions/queries_invalid_identifiers.py @@ -0,0 +1,130 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "get_invalid_identifiers", + "get_third_party_stat", + "insert_invalid_identifiers", + "insert_third_party_stat", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.attrs.functions import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +async def insert_invalid_identifiers(conn: ConnectionLike, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + column_3p_ : str | None + new_notes : str + + """ + await conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +async def get_invalid_identifiers(conn: ConnectionLike, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + models.TestInvalidIdentifier + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + +async def insert_third_party_stat(conn: ConnectionLike, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + total : int + + """ + await conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +async def get_third_party_stat(conn: ConnectionLike, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Parameters + ---------- + conn : ConnectionLike + Connection object of type `ConnectionLike` used to execute the query. + id_ : int + + Returns + ------- + models.Model3RdPartyStat + Result fetched from the db. Will be `None` if not found. + + """ + row = await (await conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/attrs/ruff.toml b/test/driver_psycopg_async/attrs/ruff.toml new file mode 100644 index 00000000..3047247e --- /dev/null +++ b/test/driver_psycopg_async/attrs/ruff.toml @@ -0,0 +1,5 @@ +extend="../../../ruff.toml" + + +[lint.pydocstyle] +convention = "numpy" \ No newline at end of file diff --git a/test/driver_psycopg_async/attrs/test_psycopg_attrs_classes.py b/test/driver_psycopg_async/attrs/test_psycopg_attrs_classes.py new file mode 100644 index 00000000..85d4b090 --- /dev/null +++ b/test/driver_psycopg_async/attrs/test_psycopg_attrs_classes.py @@ -0,0 +1,822 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows +import math + +import pytest +import pytest_asyncio + +from test.driver_psycopg_async.attrs.classes import enums +from test.driver_psycopg_async.attrs.classes import models +from test.driver_psycopg_async.attrs.classes import queries +from test.driver_psycopg_async.attrs.classes import queries_enum_override + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestAttrsClasses: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_async_conn) + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_enum_override_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_async_conn) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::create") + async def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + await queries_obj.create_one_test_postgres_type( + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::create_inner", depends=["TestAttrsClasses::create"]) + async def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + await queries_obj.create_one_test_postgres_inner_type( + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::create_inner"], name="TestAttrsClasses::get_one") + async def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one"], name="TestAttrsClasses::get_one_none") + async def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_none"], name="TestAttrsClasses::get_one_inner") + async def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_inner"], name="TestAttrsClasses::get_one_inner_none") + async def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_inner_none"], name="TestAttrsClasses::get_one_timestamp") + async def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_timestamp"], name="TestAttrsClasses::get_one_timestamp_none") + async def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_timestamp"], name="TestAttrsClasses::get_one_bytea") + async def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_bytea"], name="TestAttrsClasses::get_one_bytea_none") + async def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_bytea"], name="TestAttrsClasses::get_many") + async def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_many"], name="TestAttrsClasses::get_many_timestamp") + async def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_many_timestamp"], name="TestAttrsClasses::get_many_bytea") + async def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_many_bytea"], name="TestAttrsClasses::get_embedded") + async def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_embedded"], name="TestAttrsClasses::get_embedded_none") + async def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_embedded_none"], name="TestAttrsClasses::get_all_embedded") + async def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_all_embedded"], name="TestAttrsClasses::get_all_embedded_none") + async def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_all_embedded"], name="TestAttrsClasses::get_many_iterator") + async def test_get_many_iterator( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + results = queries_obj.get_many_test_iterator_postgres_type(id_=model.id_) + async with queries_obj.conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_many_iterator"], name="TestAttrsClasses::delete") + async def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::delete"], name="TestAttrsClasses::delete_inner") + async def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::create_result") + async def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_result_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::create_result"], name="TestAttrsClasses::update_result") + async def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::update_result"], name="TestAttrsClasses::delete_result") + async def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::create_rows") + async def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_rows_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::create_rows"], name="TestAttrsClasses::update_rows") + async def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::update_rows"], name="TestAttrsClasses::delete_rows") + async def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::delete_rows"], name="TestAttrsClasses::copy_from") + async def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries_obj.test_copy_from(params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries_obj.create_rows_table() + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::insert_type_override", + ) + async def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_type_override", + depends=["TestAttrsClasses::insert_type_override"], + ) + async def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_type_override_none", + depends=["TestAttrsClasses::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::get_many_type_override", + depends=["TestAttrsClasses::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_text_type_override", + depends=["TestAttrsClasses::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_text_type_override_none", + depends=["TestAttrsClasses::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::get_many_text_type_override", + depends=["TestAttrsClasses::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_text_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsClasses::delete_type_override", + depends=["TestAttrsClasses::get_many_text_type_override"], + ) + async def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.delete_type_override(id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::insert_enum") + async def test_insert_enum(self, queries_obj: queries.Queries) -> None: + await queries_obj.insert_one_test_enum_type(id_=510001, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::get_enum", depends=["TestAttrsClasses::insert_enum"]) + async def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=510001) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::get_enum_value", depends=["TestAttrsClasses::get_enum"]) + async def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=510001) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum"]) + async def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum"]) + async def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::get_many_enums", depends=["TestAttrsClasses::get_enum_value"]) + async def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_many_test_enum_types() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::get_many_enums"]) + async def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert await queries_obj.delete_one_test_enum_type(id_=510001) == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::insert_enum_override") + async def test_insert_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override_obj.insert_enum_override(id_=520001, mood_test="happy") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum_override"]) + async def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=520001) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum_override"]) + async def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::list_enum_override", depends=["TestAttrsClasses::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520001]) + assert len(rows) == 1 + assert rows[0].mood_test == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + results = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520001]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path; going through the conn + # property also covers its generated accessor. + async with queries_enum_override_obj.conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520001: "happy"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsClasses::count_enum_override", depends=["TestAttrsClasses::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + count = await queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.HAPPY, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsClasses::count_enum_override"]) + async def test_delete_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520001}) + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = await no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.HAPPY]) + assert count is None diff --git a/test/driver_psycopg_async/attrs/test_psycopg_attrs_functions.py b/test/driver_psycopg_async/attrs/test_psycopg_attrs_functions.py new file mode 100644 index 00000000..7bab6ddc --- /dev/null +++ b/test/driver_psycopg_async/attrs/test_psycopg_attrs_functions.py @@ -0,0 +1,899 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows +import math + +import pytest + +from test.driver_psycopg_async.attrs.functions import enums +from test.driver_psycopg_async.attrs.functions import models +from test.driver_psycopg_async.attrs.functions import queries +from test.driver_psycopg_async.attrs.functions import queries_enum_override + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestAttrsFunctions: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::create") + async def test_create( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.create_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::create2", depends=["TestAttrsFunctions::create"]) + async def test_create_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.create_one_test_postgres_inner_type( + conn=psycopg_async_conn, + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::create2"], name="TestAttrsFunctions::get_one") + async def test_get_one( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one"], name="TestAttrsFunctions::get_one_none") + async def test_get_one_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_none"], name="TestAttrsFunctions::get_one_inner") + async def test_get_one_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_inner"], name="TestAttrsFunctions::get_one_inner_none") + async def test_get_one_inner_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_inner_none"], name="TestAttrsFunctions::get_one_timestamp") + async def test_get_one_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_timestamp"], name="TestAttrsFunctions::get_one_timestamp_none") + async def test_get_one_timestamp_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_timestamp_none"], name="TestAttrsFunctions::get_one_bytea") + async def test_get_one_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_bytea"], name="TestAttrsFunctions::get_one_bytea_none") + async def test_get_one_bytea_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_bytea_none"], name="TestAttrsFunctions::get_many") + async def test_get_many( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_many"], name="TestAttrsFunctions::get_many_timestamp") + async def test_get_many_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestAttrsFunctions::get_many_timestamp"], + name="TestAttrsFunctions::get_many_bytea", + ) + async def test_get_many_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_many_bytea"], name="TestAttrsFunctions::get_embedded") + async def test_get_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_embedded"], name="TestAttrsFunctions::get_embedded_none") + async def test_get_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_embedded_none"], name="TestAttrsFunctions::get_all_embedded") + async def test_get_all_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_all_embedded"], name="TestAttrsFunctions::get_all_embedded_none") + async def test_get_all_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestAttrsFunctions::get_all_embedded_none"], + name="TestAttrsFunctions::get_many_iterator", + ) + async def test_get_many_iterator( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_async_conn, id_=model.id_) + async with psycopg_async_conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_many_iterator"], name="TestAttrsFunctions::delete") + async def test_delete( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.delete_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::delete"], name="TestAttrsFunctions::delete_inner") + async def test_delete_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.delete_one_test_postgres_inner_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::create_result") + async def test_create_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_result_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::create_result"], name="TestAttrsFunctions::update_result") + async def test_update_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::update_result"], name="TestAttrsFunctions::delete_result") + async def test_delete_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::create_rows") + async def test_create_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_rows_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::create_rows"], name="TestAttrsFunctions::update_rows") + async def test_update_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::update_rows"], name="TestAttrsFunctions::delete_rows") + async def test_delete_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::delete_rows"], name="TestAttrsFunctions::copy_from") + async def test_copy_from( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries.test_copy_from(conn=psycopg_async_conn, params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.create_rows_table(conn=psycopg_async_conn) + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::insert_type_override", + ) + async def test_insert_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.insert_type_override(conn=psycopg_async_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_type_override", + depends=["TestAttrsFunctions::insert_type_override"], + ) + async def test_get_one_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_type_override_none", + depends=["TestAttrsFunctions::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::get_many_type_override", + depends=["TestAttrsFunctions::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_text_type_override", + depends=["TestAttrsFunctions::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_text_type_override_none", + depends=["TestAttrsFunctions::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::get_many_text_type_override", + depends=["TestAttrsFunctions::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestAttrsFunctions::delete_type_override", + depends=["TestAttrsFunctions::get_many_text_type_override"], + ) + async def test_delete_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.delete_type_override(conn=psycopg_async_conn, id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::insert_enum") + async def test_insert_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries.insert_one_test_enum_type(conn=psycopg_async_conn, id_=510002, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::get_enum", depends=["TestAttrsFunctions::insert_enum"]) + async def test_get_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=510002) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::get_enum_value", depends=["TestAttrsFunctions::get_enum"]) + async def test_get_enum_value(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=510002) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum"]) + async def test_get_enum_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum"]) + async def test_get_enum_value_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::get_many_enums", depends=["TestAttrsFunctions::get_enum_value"]) + async def test_get_many_enums(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_many_test_enum_types(conn=psycopg_async_conn) + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_many_enums"]) + async def test_delete_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries.delete_one_test_enum_type(conn=psycopg_async_conn, id_=510002) == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::insert_enum_override") + async def test_insert_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override.insert_enum_override(conn=psycopg_async_conn, id_=520002, mood_test="happy") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum_override"]) + async def test_get_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=520002) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum_override"]) + async def test_get_enum_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::list_enum_override", depends=["TestAttrsFunctions::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[520002]) + assert len(rows) == 1 + assert rows[0].mood_test == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[520002]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path. + async with psycopg_async_conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520002: "happy"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestAttrsFunctions::count_enum_override", depends=["TestAttrsFunctions::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + count = await queries_enum_override.count_enum_override_by_moods(conn=psycopg_async_conn, dollar_1=[enums.TestMood.HAPPY, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + count = await queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestAttrsFunctions::count_enum_override"]) + async def test_delete_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520002}) diff --git a/test/driver_psycopg_async/dataclass/__init__.py b/test/driver_psycopg_async/dataclass/__init__.py new file mode 100644 index 00000000..242b9d5f --- /dev/null +++ b/test/driver_psycopg_async/dataclass/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""Package to allow importing for psycopg tests.""" diff --git a/test/driver_psycopg_async/dataclass/classes/__init__.py b/test/driver_psycopg_async/dataclass/classes/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/dataclass/classes/enums.py b/test/driver_psycopg_async/dataclass/classes/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/dataclass/classes/models.py b/test/driver_psycopg_async/dataclass/classes/models.py new file mode 100644 index 00000000..ca3c43f9 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/models.py @@ -0,0 +1,275 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +import dataclasses +import typing + +if typing.TYPE_CHECKING: + from collections import UserString + from test.driver_psycopg_async.dataclass.classes import enums + import collections.abc + import datetime + import decimal + import uuid + + +@dataclasses.dataclass() +class Model3RdPartyStat: + """Model representing Model3RdPartyStat. + + Attributes: + id_: int + total: int + """ + + id_: int + total: int + + +@dataclasses.dataclass() +class TestEnumOverride: + """Model representing TestEnumOverride. + + Attributes: + id_: int + mood_test: str + """ + + id_: int + mood_test: str + + +@dataclasses.dataclass() +class TestEnumType: + """Model representing TestEnumType. + + Attributes: + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + """ + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +@dataclasses.dataclass() +class TestFieldNaming: + """Model representing TestFieldNaming. + + Attributes: + id_: int + outputs: str + """ + + id_: int + outputs: str + + +@dataclasses.dataclass() +class TestInnerPostgresType: + """Model representing TestInnerPostgresType. + + Attributes: + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + """ + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +@dataclasses.dataclass() +class TestInvalidIdentifier: + """Model representing TestInvalidIdentifier. + + Attributes: + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + """ + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +@dataclasses.dataclass() +class TestPostgresType: + """Model representing TestPostgresType. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +@dataclasses.dataclass() +class TestTypeOverride: + """Model representing TestTypeOverride. + + Attributes: + id_: int + text_test: UserString | None + """ + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/dataclass/classes/queries.py b/test/driver_psycopg_async/dataclass/classes/queries.py new file mode 100644 index 00000000..c121d05d --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/queries.py @@ -0,0 +1,2087 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "Queries", + "QueryResults", + "TestCopyFromParams", +) + +from collections import UserString +import dataclasses +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import datetime + import decimal + import uuid + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.classes import enums +from test.driver_psycopg_async.dataclass.classes import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@dataclasses.dataclass() +class GetEmbeddedTestPostgresTypeRow: + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +@dataclasses.dataclass() +class GetAllEmbeddedTestPostgresTypeRow: + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes: + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + """ + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +@dataclasses.dataclass() +class TestCopyFromParams: + """Model representing TestCopyFromParams. + + Attributes: + id_: int + float_test: float + int_test: int + """ + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class Queries: + """Queries from file queries.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def get_one_test_postgres_type(self, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_inner_test_postgres_type(self, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Args: + table_id: int. + + Returns: + Result of type `models.TestInnerPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_test_timestamp_postgres_type(self, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `datetime.datetime` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + async def get_one_test_bytea_postgres_type(self, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `memoryview` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + def get_many_test_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_iterator_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_timestamp_postgres_type(self, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[datetime.datetime]` that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(self._conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + def get_many_test_bytea_postgres_type(self, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[memoryview]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(self._conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + async def get_embedded_test_postgres_type(self, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `GetEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def get_all_embedded_test_postgres_type(self, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `GetAllEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def create_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def create_one_test_postgres_inner_type( + self, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + table_id: int. + serial_test: int | None. + serial4_test: int | None. + bigserial_test: int | None. + smallserial_test: int | None. + int_test: int | None. + bigint_test: int | None. + smallint_test: int | None. + float_test: float | None. + double_precision_test: float | None. + real_test: float | None. + numeric_test: decimal.Decimal | None. + money_test: str | None. + bool_test: bool | None. + json_test: str | None. + jsonb_test: str | None. + bytea_test: memoryview | None. + date_test: datetime.date | None. + time_test: datetime.time | None. + timetz_test: datetime.time | None. + timestamp_test: datetime.datetime | None. + timestamptz_test: datetime.datetime | None. + interval_test: datetime.timedelta | None. + text_test: str | None. + varchar_test: str | None. + bpchar_test: str | None. + char_test: str | None. + citext_test: str | None. + uuid_test: uuid.UUID | None. + inet_test: str | None. + cidr_test: str | None. + macaddr_test: str | None. + macaddr8_test: str | None. + ltree_test: str | None. + lquery_test: str | None. + ltxtquery_test: str | None. + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + async def delete_one_test_postgres_type(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_test_postgres_inner_type(self, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Args: + table_id: int. + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + async def create_result_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def update_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def create_rows_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + async def update_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def delete_one_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def create_rows_table(self) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + async def test_copy_from(self, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Args: + params: collections.abc.Sequence[TestCopyFromParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + async def insert_type_override(self, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Args: + id_: int. + text_test: UserString | None. + """ + await self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + async def get_one_type_override(self, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestTypeOverride` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + def get_many_type_override(self, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestTypeOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(self._conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def get_one_text_type_override(self, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `UserString` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + def get_many_text_type_override(self, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[UserString | None]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(self._conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def delete_type_override(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + """ + await self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + async def insert_one_test_enum_type(self, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + id_: int. + mood: enums.TestMood. + maybe_mood: enums.TestMood | None. + """ + await self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + async def get_one_test_enum_type(self, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestEnumType` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + async def get_one_test_enum_value(self, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `enums.TestMood` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + def get_many_test_enum_types(self) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Returns: + Helper class of type `QueryResults[models.TestEnumType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(self._conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + async def delete_one_test_enum_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/dataclass/classes/queries_copy_override.py b/test/driver_psycopg_async/dataclass/classes/queries_copy_override.py new file mode 100644 index 00000000..ea83bbfd --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/queries_copy_override.py @@ -0,0 +1,117 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "QueriesCopyOverride", +) + +import dataclasses +import decimal +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +@dataclasses.dataclass() +class CopyOverrideRowsParams: + """Model representing CopyOverrideRowsParams. + + Attributes: + id_: int + amount: float + co_l: str + """ + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +class QueriesCopyOverride: + """Queries from file queries_copy_override.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def copy_override_rows(self, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Args: + params: collections.abc.Sequence[CopyOverrideRowsParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + async def count_copy_override_rows(self) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + async def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + await self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/dataclass/classes/queries_enum_override.py b/test/driver_psycopg_async/dataclass/classes/queries_enum_override.py new file mode 100644 index 00000000..fef16ad3 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/queries_enum_override.py @@ -0,0 +1,211 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueriesEnumOverride", + "QueryResults", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.classes import enums +from test.driver_psycopg_async.dataclass.classes import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class QueriesEnumOverride: + """Queries from file queries_enum_override.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def insert_enum_override(self, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + id_: int. + mood_test: str. + """ + await self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + async def get_enum_override_mood(self, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `str` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + def list_enum_override_by_ids(self, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Args: + dollar_1: collections.abc.Sequence[int]. + + Returns: + Helper class of type `QueryResults[models.TestEnumOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(self._conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + async def count_enum_override_by_moods(self, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Args: + dollar_1: collections.abc.Sequence[enums.TestMood]. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/dataclass/classes/queries_field_namings.py b/test/driver_psycopg_async/dataclass/classes/queries_field_namings.py new file mode 100644 index 00000000..21495123 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/queries_field_namings.py @@ -0,0 +1,143 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "QueriesFieldNamings", +) + +import dataclasses +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.classes import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@dataclasses.dataclass() +class GetJoinedFieldNamingsRow: + """Model representing GetJoinedFieldNamingsRow. + + Attributes: + outputs: str + outputs_2: str + """ + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +class QueriesFieldNamings: + """Queries from file queries_field_namings.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def get_field_naming(self, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestFieldNaming` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + async def get_joined_field_namings(self, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `GetJoinedFieldNamingsRow` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + async def set_field_naming_outputs(self, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Args: + id_: int. + outputs: str. + outputs_2: str. + """ + await self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/dataclass/classes/queries_invalid_identifiers.py b/test/driver_psycopg_async/dataclass/classes/queries_invalid_identifiers.py new file mode 100644 index 00000000..b1691193 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/classes/queries_invalid_identifiers.py @@ -0,0 +1,125 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("QueriesInvalidIdentifiers",) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.classes import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +class QueriesInvalidIdentifiers: + """Queries from file queries_invalid_identifiers.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def insert_invalid_identifiers(self, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + id_: int. + column_3p_: str | None. + new_notes: str. + """ + await self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + async def get_invalid_identifiers(self, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestInvalidIdentifier` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + async def insert_third_party_stat(self, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + id_: int. + total: int. + """ + await self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + async def get_third_party_stat(self, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.Model3RdPartyStat` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/dataclass/functions/__init__.py b/test/driver_psycopg_async/dataclass/functions/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/dataclass/functions/enums.py b/test/driver_psycopg_async/dataclass/functions/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/dataclass/functions/models.py b/test/driver_psycopg_async/dataclass/functions/models.py new file mode 100644 index 00000000..6229c025 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/models.py @@ -0,0 +1,294 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestConverter", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +import dataclasses +import typing + +if typing.TYPE_CHECKING: + from collections import UserString + from test.converters import Preferences + from test.driver_psycopg_async.dataclass.functions import enums + import collections.abc + import datetime + import decimal + import uuid + + +@dataclasses.dataclass() +class Model3RdPartyStat: + """Model representing Model3RdPartyStat. + + Attributes: + id_: int + total: int + """ + + id_: int + total: int + + +@dataclasses.dataclass() +class TestConverter: + """Model representing TestConverter. + + Attributes: + id_: int + prefs: Preferences + maybe_prefs: Preferences | None + tags: frozenset[str] + """ + + id_: int + prefs: Preferences + maybe_prefs: Preferences | None + tags: frozenset[str] + + +@dataclasses.dataclass() +class TestEnumOverride: + """Model representing TestEnumOverride. + + Attributes: + id_: int + mood_test: str + """ + + id_: int + mood_test: str + + +@dataclasses.dataclass() +class TestEnumType: + """Model representing TestEnumType. + + Attributes: + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + """ + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +@dataclasses.dataclass() +class TestFieldNaming: + """Model representing TestFieldNaming. + + Attributes: + id_: int + outputs: str + """ + + id_: int + outputs: str + + +@dataclasses.dataclass() +class TestInnerPostgresType: + """Model representing TestInnerPostgresType. + + Attributes: + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + """ + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +@dataclasses.dataclass() +class TestInvalidIdentifier: + """Model representing TestInvalidIdentifier. + + Attributes: + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + """ + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +@dataclasses.dataclass() +class TestPostgresType: + """Model representing TestPostgresType. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +@dataclasses.dataclass() +class TestTypeOverride: + """Model representing TestTypeOverride. + + Attributes: + id_: int + text_test: UserString | None + """ + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/dataclass/functions/queries.py b/test/driver_psycopg_async/dataclass/functions/queries.py new file mode 100644 index 00000000..c0a3bc5e --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/queries.py @@ -0,0 +1,2198 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "QueryResults", + "TestCopyFromParams", + "create_one_test_postgres_inner_type", + "create_one_test_postgres_type", + "create_result_one_test_postgres_type", + "create_rows_one_test_postgres_type", + "create_rows_table", + "delete_one_result_test_postgres_type", + "delete_one_rows_test_postgres_type", + "delete_one_test_enum_type", + "delete_one_test_postgres_inner_type", + "delete_one_test_postgres_type", + "delete_type_override", + "get_all_embedded_test_postgres_type", + "get_embedded_test_postgres_type", + "get_many_test_bytea_postgres_type", + "get_many_test_enum_types", + "get_many_test_iterator_postgres_type", + "get_many_test_postgres_type", + "get_many_test_timestamp_postgres_type", + "get_many_text_type_override", + "get_many_type_override", + "get_one_inner_test_postgres_type", + "get_one_test_bytea_postgres_type", + "get_one_test_enum_type", + "get_one_test_enum_value", + "get_one_test_postgres_type", + "get_one_test_timestamp_postgres_type", + "get_one_text_type_override", + "get_one_type_override", + "insert_one_test_enum_type", + "insert_type_override", + "test_copy_from", + "update_result_test_postgres_type", + "update_rows_test_postgres_type", +) + +from collections import UserString +import dataclasses +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import datetime + import decimal + import uuid + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.functions import enums +from test.driver_psycopg_async.dataclass.functions import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@dataclasses.dataclass() +class GetEmbeddedTestPostgresTypeRow: + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +@dataclasses.dataclass() +class GetAllEmbeddedTestPostgresTypeRow: + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes: + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + """ + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +@dataclasses.dataclass() +class TestCopyFromParams: + """Model representing TestCopyFromParams. + + Attributes: + id_: int + float_test: float + int_test: int + """ + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def get_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_inner_test_postgres_type(conn: ConnectionLike, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + table_id: int. + + Returns: + Result of type `models.TestInnerPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `datetime.datetime` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + +async def get_one_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `memoryview` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + +def get_many_test_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_iterator_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[datetime.datetime]` that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + +def get_many_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[memoryview]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +async def get_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `GetEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def get_all_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `GetAllEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def create_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def create_one_test_postgres_inner_type( + conn: ConnectionLike, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + table_id: int. + serial_test: int | None. + serial4_test: int | None. + bigserial_test: int | None. + smallserial_test: int | None. + int_test: int | None. + bigint_test: int | None. + smallint_test: int | None. + float_test: float | None. + double_precision_test: float | None. + real_test: float | None. + numeric_test: decimal.Decimal | None. + money_test: str | None. + bool_test: bool | None. + json_test: str | None. + jsonb_test: str | None. + bytea_test: memoryview | None. + date_test: datetime.date | None. + time_test: datetime.time | None. + timetz_test: datetime.time | None. + timestamp_test: datetime.datetime | None. + timestamptz_test: datetime.datetime | None. + interval_test: datetime.timedelta | None. + text_test: str | None. + varchar_test: str | None. + bpchar_test: str | None. + char_test: str | None. + citext_test: str | None. + uuid_test: uuid.UUID | None. + inet_test: str | None. + cidr_test: str | None. + macaddr_test: str | None. + macaddr8_test: str | None. + ltree_test: str | None. + lquery_test: str | None. + ltxtquery_test: str | None. + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +async def delete_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_test_postgres_inner_type(conn: ConnectionLike, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + table_id: int. + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +async def create_result_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def create_rows_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +async def update_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def delete_one_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def create_rows_table(conn: ConnectionLike) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + params: collections.abc.Sequence[TestCopyFromParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +async def insert_type_override(conn: ConnectionLike, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + text_test: UserString | None. + """ + await conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +async def get_one_type_override(conn: ConnectionLike, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestTypeOverride` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + +def get_many_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestTypeOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def get_one_text_type_override(conn: ConnectionLike, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `UserString` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + +def get_many_text_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[UserString | None]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def delete_type_override(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + """ + await conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +async def insert_one_test_enum_type(conn: ConnectionLike, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + mood: enums.TestMood. + maybe_mood: enums.TestMood | None. + """ + await conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +async def get_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestEnumType` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + +async def get_one_test_enum_value(conn: ConnectionLike, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `enums.TestMood` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + +def get_many_test_enum_types(conn: ConnectionLike) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + + Returns: + Helper class of type `QueryResults[models.TestEnumType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + +async def delete_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/dataclass/functions/queries_converters.py b/test/driver_psycopg_async/dataclass/functions/queries_converters.py new file mode 100644 index 00000000..ff02642f --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/queries_converters.py @@ -0,0 +1,271 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_converters.sql +"""Module containing queries from file queries_converters.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueryResults", + "delete_converted", + "find_converter_array_by_labels", + "get_converted", + "get_converter_array_label", + "insert_converted", + "insert_converter_array_row", + "list_converted_by_tags", +) + +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import test.converters +import typing + +if typing.TYPE_CHECKING: + from pathlib import PurePosixPath + from test.converters import Preferences + import collections.abc + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.functions import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +INSERT_CONVERTED: typing.Final[typing.LiteralString] = """-- name: InsertConverted :exec +INSERT INTO test_converters (id, prefs, maybe_prefs, tags) VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s) +""" + +GET_CONVERTED: typing.Final[typing.LiteralString] = """-- name: GetConverted :one +SELECT id, prefs, maybe_prefs, tags FROM test_converters WHERE id = %(p1)s +""" + +LIST_CONVERTED_BY_TAGS: typing.Final[typing.LiteralString] = """-- name: ListConvertedByTags :many +SELECT id FROM test_converters WHERE tags = %(p1)s +""" + +DELETE_CONVERTED: typing.Final[typing.LiteralString] = """-- name: DeleteConverted :exec +DELETE FROM test_converters WHERE id = %(p1)s +""" + +INSERT_CONVERTER_ARRAY_ROW: typing.Final[typing.LiteralString] = """-- name: InsertConverterArrayRow :exec +INSERT INTO test_converter_array (id, label) VALUES (%(p1)s, %(p2)s) +""" + +GET_CONVERTER_ARRAY_LABEL: typing.Final[typing.LiteralString] = """-- name: GetConverterArrayLabel :one +SELECT label FROM test_converter_array WHERE id = %(p1)s +""" + +FIND_CONVERTER_ARRAY_BY_LABELS: typing.Final[typing.LiteralString] = """-- name: FindConverterArrayByLabels :many +SELECT id FROM test_converter_array WHERE label = ANY(%(p1)s::converter_label[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def insert_converted(conn: ConnectionLike, *, id_: int, prefs: Preferences, maybe_prefs: Preferences | None, tags: frozenset[str]) -> None: + """Execute SQL query with `name: InsertConverted :exec`. + + ```sql + INSERT INTO test_converters (id, prefs, maybe_prefs, tags) VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + prefs: Preferences. + maybe_prefs: Preferences | None. + tags: frozenset[str]. + """ + await conn.execute(INSERT_CONVERTED, {"p1": id_, "p2": test.converters.encode_preferences(prefs), "p3": test.converters.encode_preferences(maybe_prefs) if maybe_prefs is not None else None, "p4": test.converters.encode_tags(tags)}) + + +async def get_converted(conn: ConnectionLike, *, id_: int) -> models.TestConverter | None: + """Fetch one from the db using the SQL query with `name: GetConverted :one`. + + ```sql + SELECT id, prefs, maybe_prefs, tags FROM test_converters WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestConverter` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_CONVERTED, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestConverter(id_=row[0], prefs=test.converters.decode_preferences(row[1]), maybe_prefs=test.converters.decode_preferences(row[2]) if row[2] is not None else None, tags=test.converters.decode_tags(row[3])) + + +def list_converted_by_tags(conn: ConnectionLike, *, tags: frozenset[str]) -> QueryResults[int]: + """Fetch many from the db using the SQL query with `name: ListConvertedByTags :many`. + + ```sql + SELECT id FROM test_converters WHERE tags = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + tags: frozenset[str]. + + Returns: + Helper class of type `QueryResults[int]` that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(conn, LIST_CONVERTED_BY_TAGS, operator.itemgetter(0), {"p1": test.converters.encode_tags(tags)}) + + +async def delete_converted(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteConverted :exec`. + + ```sql + DELETE FROM test_converters WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + """ + await conn.execute(DELETE_CONVERTED, {"p1": id_}) + + +async def insert_converter_array_row(conn: ConnectionLike, *, id_: int, label: PurePosixPath) -> None: + """Execute SQL query with `name: InsertConverterArrayRow :exec`. + + ```sql + INSERT INTO test_converter_array (id, label) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + label: PurePosixPath. + """ + await conn.execute(INSERT_CONVERTER_ARRAY_ROW, {"p1": id_, "p2": test.converters.encode_label(label)}) + + +async def get_converter_array_label(conn: ConnectionLike, *, id_: int) -> PurePosixPath | None: + """Fetch one from the db using the SQL query with `name: GetConverterArrayLabel :one`. + + ```sql + SELECT label FROM test_converter_array WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `PurePosixPath` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_CONVERTER_ARRAY_LABEL, {"p1": id_})).fetchone() + if row is None: + return None + return test.converters.decode_label(row[0]) + + +def find_converter_array_by_labels(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[PurePosixPath]) -> QueryResults[int]: + """Fetch many from the db using the SQL query with `name: FindConverterArrayByLabels :many`. + + ```sql + SELECT id FROM test_converter_array WHERE label = ANY(%(p1)s::converter_label[]) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + dollar_1: collections.abc.Sequence[PurePosixPath]. + + Returns: + Helper class of type `QueryResults[int]` that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(conn, FIND_CONVERTER_ARRAY_BY_LABELS, operator.itemgetter(0), {"p1": [test.converters.encode_label(v) for v in dollar_1]}) diff --git a/test/driver_psycopg_async/dataclass/functions/queries_copy_override.py b/test/driver_psycopg_async/dataclass/functions/queries_copy_override.py new file mode 100644 index 00000000..16b0976c --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/queries_copy_override.py @@ -0,0 +1,107 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "copy_override_rows", + "count_copy_override_rows", + "delete_copy_override_rows", +) + +import dataclasses +import decimal +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +@dataclasses.dataclass() +class CopyOverrideRowsParams: + """Model representing CopyOverrideRowsParams. + + Attributes: + id_: int + amount: float + co_l: str + """ + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +async def copy_override_rows(conn: ConnectionLike, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + params: collections.abc.Sequence[CopyOverrideRowsParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +async def count_copy_override_rows(conn: ConnectionLike) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + +async def delete_copy_override_rows(conn: ConnectionLike) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + await conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/dataclass/functions/queries_enum_override.py b/test/driver_psycopg_async/dataclass/functions/queries_enum_override.py new file mode 100644 index 00000000..a2b4b073 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/queries_enum_override.py @@ -0,0 +1,202 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueryResults", + "count_enum_override_by_moods", + "get_enum_override_mood", + "insert_enum_override", + "list_enum_override_by_ids", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.functions import enums +from test.driver_psycopg_async.dataclass.functions import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def insert_enum_override(conn: ConnectionLike, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + mood_test: str. + """ + await conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +async def get_enum_override_mood(conn: ConnectionLike, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `str` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + +def list_enum_override_by_ids(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + dollar_1: collections.abc.Sequence[int]. + + Returns: + Helper class of type `QueryResults[models.TestEnumOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + +async def count_enum_override_by_moods(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + dollar_1: collections.abc.Sequence[enums.TestMood]. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/dataclass/functions/queries_field_namings.py b/test/driver_psycopg_async/dataclass/functions/queries_field_namings.py new file mode 100644 index 00000000..8dd0a475 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/queries_field_namings.py @@ -0,0 +1,130 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "get_field_naming", + "get_joined_field_namings", + "set_field_naming_outputs", +) + +import dataclasses +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.functions import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +@dataclasses.dataclass() +class GetJoinedFieldNamingsRow: + """Model representing GetJoinedFieldNamingsRow. + + Attributes: + outputs: str + outputs_2: str + """ + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +async def get_field_naming(conn: ConnectionLike, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestFieldNaming` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +async def get_joined_field_namings(conn: ConnectionLike, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `GetJoinedFieldNamingsRow` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +async def set_field_naming_outputs(conn: ConnectionLike, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + outputs: str. + outputs_2: str. + """ + await conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/dataclass/functions/queries_invalid_identifiers.py b/test/driver_psycopg_async/dataclass/functions/queries_invalid_identifiers.py new file mode 100644 index 00000000..93212aa4 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/functions/queries_invalid_identifiers.py @@ -0,0 +1,118 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "get_invalid_identifiers", + "get_third_party_stat", + "insert_invalid_identifiers", + "insert_third_party_stat", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.dataclass.functions import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +async def insert_invalid_identifiers(conn: ConnectionLike, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + column_3p_: str | None. + new_notes: str. + """ + await conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +async def get_invalid_identifiers(conn: ConnectionLike, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestInvalidIdentifier` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + +async def insert_third_party_stat(conn: ConnectionLike, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + total: int. + """ + await conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +async def get_third_party_stat(conn: ConnectionLike, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.Model3RdPartyStat` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/dataclass/ruff.toml b/test/driver_psycopg_async/dataclass/ruff.toml new file mode 100644 index 00000000..f37cac11 --- /dev/null +++ b/test/driver_psycopg_async/dataclass/ruff.toml @@ -0,0 +1,5 @@ +extend="../../../ruff.toml" + + +[lint.pydocstyle] +convention = "google" \ No newline at end of file diff --git a/test/driver_psycopg_async/dataclass/test_psycopg_dataclass_classes.py b/test/driver_psycopg_async/dataclass/test_psycopg_dataclass_classes.py new file mode 100644 index 00000000..9864f04c --- /dev/null +++ b/test/driver_psycopg_async/dataclass/test_psycopg_dataclass_classes.py @@ -0,0 +1,839 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows + +import math + +import pytest +import pytest_asyncio + +from test.driver_psycopg_async.dataclass.classes import enums +from test.driver_psycopg_async.dataclass.classes import models +from test.driver_psycopg_async.dataclass.classes import queries +from test.driver_psycopg_async.dataclass.classes import queries_enum_override + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestDataclassClasses: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_async_conn) + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_enum_override_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_async_conn) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::create") + async def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + await queries_obj.create_one_test_postgres_type( + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::create_inner", depends=["TestDataclassClasses::create"]) + async def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + await queries_obj.create_one_test_postgres_inner_type( + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::create_inner"], name="TestDataclassClasses::get_one") + async def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one"], name="TestDataclassClasses::get_one_none") + async def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one_none"], name="TestDataclassClasses::get_one_inner") + async def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one_inner"], name="TestDataclassClasses::get_one_inner_none") + async def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_one_inner_none"], + name="TestDataclassClasses::get_one_timestamp", + ) + async def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one_timestamp"], name="TestDataclassClasses::get_one_timestamp_none") + async def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_one_timestamp_none"], + name="TestDataclassClasses::get_one_bytea", + ) + async def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one_bytea"], name="TestDataclassClasses::get_one_bytea_none") + async def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one_bytea_none"], name="TestDataclassClasses::get_many") + async def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_many"], name="TestDataclassClasses::get_many_timestamp") + async def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_many_timestamp"], + name="TestDataclassClasses::get_many_bytea", + ) + async def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_many_bytea"], name="TestDataclassClasses::get_embedded") + async def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_embedded"], name="TestDataclassClasses::get_embedded_none") + async def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_embedded_none"], + name="TestDataclassClasses::get_all_embedded", + ) + async def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_all_embedded"], name="TestDataclassClasses::get_all_embedded_none") + async def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_all_embedded_none"], + name="TestDataclassClasses::get_many_iterator", + ) + async def test_get_many_iterator( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + results = queries_obj.get_many_test_iterator_postgres_type(id_=model.id_) + async with queries_obj.conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_many_iterator"], name="TestDataclassClasses::delete") + async def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::delete"], name="TestDataclassClasses::delete_inner") + async def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::create_result") + async def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_result_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::create_result"], name="TestDataclassClasses::update_result") + async def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::update_result"], name="TestDataclassClasses::delete_result") + async def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::create_rows") + async def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_rows_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::create_rows"], name="TestDataclassClasses::update_rows") + async def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::update_rows"], name="TestDataclassClasses::delete_rows") + async def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::delete_rows"], name="TestDataclassClasses::copy_from") + async def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries_obj.test_copy_from(params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries_obj.create_rows_table() + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::insert_type_override", + ) + async def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_type_override", + depends=["TestDataclassClasses::insert_type_override"], + ) + async def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_type_override_none", + depends=["TestDataclassClasses::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::get_many_type_override", + depends=["TestDataclassClasses::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_text_type_override", + depends=["TestDataclassClasses::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_text_type_override_none", + depends=["TestDataclassClasses::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::get_many_text_type_override", + depends=["TestDataclassClasses::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_text_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassClasses::delete_type_override", + depends=["TestDataclassClasses::get_many_text_type_override"], + ) + async def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.delete_type_override(id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::insert_enum") + async def test_insert_enum(self, queries_obj: queries.Queries) -> None: + await queries_obj.insert_one_test_enum_type(id_=510003, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::get_enum", depends=["TestDataclassClasses::insert_enum"]) + async def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=510003) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::get_enum_value", depends=["TestDataclassClasses::get_enum"]) + async def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=510003) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum"]) + async def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum"]) + async def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::get_many_enums", depends=["TestDataclassClasses::get_enum_value"]) + async def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_many_test_enum_types() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::get_many_enums"]) + async def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert await queries_obj.delete_one_test_enum_type(id_=510003) == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::insert_enum_override") + async def test_insert_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override_obj.insert_enum_override(id_=520003, mood_test="happy") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum_override"]) + async def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=520003) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum_override"]) + async def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::list_enum_override", depends=["TestDataclassClasses::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520003]) + assert len(rows) == 1 + assert rows[0].mood_test == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + results = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520003]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path; going through the conn + # property also covers its generated accessor. + async with queries_enum_override_obj.conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520003: "happy"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassClasses::count_enum_override", depends=["TestDataclassClasses::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + count = await queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.HAPPY, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassClasses::count_enum_override"]) + async def test_delete_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # count_enum_override_by_moods asserts exact counts; remove the row so + # later suites against the shared database start clean. + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520003}) + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = await no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.HAPPY]) + assert count is None diff --git a/test/driver_psycopg_async/dataclass/test_psycopg_dataclass_functions.py b/test/driver_psycopg_async/dataclass/test_psycopg_dataclass_functions.py new file mode 100644 index 00000000..6bae576a --- /dev/null +++ b/test/driver_psycopg_async/dataclass/test_psycopg_dataclass_functions.py @@ -0,0 +1,1042 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows + +import math +import pathlib + +import pytest + +from test import converters +from test.driver_psycopg_async.dataclass.functions import enums +from test.driver_psycopg_async.dataclass.functions import models +from test.driver_psycopg_async.dataclass.functions import queries +from test.driver_psycopg_async.dataclass.functions import queries_converters +from test.driver_psycopg_async.dataclass.functions import queries_enum_override +from test.driver_psycopg_async.dataclass.functions import queries_invalid_identifiers + +INVALID_IDENTIFIER_ID = 706060 +CONVERTER_ID = 710001 +CONVERTER_ARRAY_ID = 720001 + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestDataclassFunctions: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::create") + async def test_create( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.create_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::create2", depends=["TestDataclassFunctions::create"]) + async def test_create_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.create_one_test_postgres_inner_type( + conn=psycopg_async_conn, + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::create2"], name="TestDataclassFunctions::get_one") + async def test_get_one( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_one"], name="TestDataclassFunctions::get_one_none") + async def test_get_one_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_one_none"], name="TestDataclassFunctions::get_one_inner") + async def test_get_one_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_one_inner"], name="TestDataclassFunctions::get_one_inner_none") + async def test_get_one_inner_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_inner_none"], + name="TestDataclassFunctions::get_one_timestamp", + ) + async def test_get_one_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_timestamp"], + name="TestDataclassFunctions::get_one_timestamp_none", + ) + async def test_get_one_timestamp_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_timestamp_none"], + name="TestDataclassFunctions::get_one_bytea", + ) + async def test_get_one_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_bytea"], + name="TestDataclassFunctions::get_one_bytea_none", + ) + async def test_get_one_bytea_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_one_bytea_none"], name="TestDataclassFunctions::get_many") + async def test_get_many( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_many"], + name="TestDataclassFunctions::get_many_timestamp", + ) + async def test_get_many_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_many_timestamp"], + name="TestDataclassFunctions::get_many_bytea", + ) + async def test_get_many_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_many_bytea"], + name="TestDataclassFunctions::get_embedded", + ) + async def test_get_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_embedded"], + name="TestDataclassFunctions::get_embedded_none", + ) + async def test_get_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_embedded_none"], + name="TestDataclassFunctions::get_all_embedded", + ) + async def test_get_all_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_all_embedded"], + name="TestDataclassFunctions::get_all_embedded_none", + ) + async def test_get_all_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_all_embedded_none"], + name="TestDataclassFunctions::get_many_iterator", + ) + async def test_get_many_iterator( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_async_conn, id_=model.id_) + async with psycopg_async_conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_many_iterator"], + name="TestDataclassFunctions::delete", + ) + async def test_delete( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.delete_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::delete"], name="TestDataclassFunctions::delete_inner") + async def test_delete_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.delete_one_test_postgres_inner_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::create_result") + async def test_create_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_result_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::create_result"], + name="TestDataclassFunctions::update_result", + ) + async def test_update_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestDataclassFunctions::update_result"], + name="TestDataclassFunctions::delete_result", + ) + async def test_delete_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::create_rows") + async def test_create_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_rows_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::create_rows"], name="TestDataclassFunctions::update_rows") + async def test_update_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::update_rows"], name="TestDataclassFunctions::delete_rows") + async def test_delete_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::delete_rows"], name="TestDataclassFunctions::copy_from") + async def test_copy_from( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries.test_copy_from(conn=psycopg_async_conn, params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.create_rows_table(conn=psycopg_async_conn) + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::insert_type_override", + ) + async def test_insert_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.insert_type_override(conn=psycopg_async_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_type_override", + depends=["TestDataclassFunctions::insert_type_override"], + ) + async def test_get_one_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_type_override_none", + depends=["TestDataclassFunctions::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::get_many_type_override", + depends=["TestDataclassFunctions::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_text_type_override", + depends=["TestDataclassFunctions::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_text_type_override_none", + depends=["TestDataclassFunctions::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::get_many_text_type_override", + depends=["TestDataclassFunctions::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestDataclassFunctions::delete_type_override", + depends=["TestDataclassFunctions::get_many_text_type_override"], + ) + async def test_delete_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.delete_type_override(conn=psycopg_async_conn, id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::insert_invalid_identifiers") + async def test_insert_invalid_identifiers(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries_invalid_identifiers.insert_invalid_identifiers(conn=psycopg_async_conn, id_=INVALID_IDENTIFIER_ID, column_3p_="3%", new_notes="hello") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_invalid_identifiers"]) + async def test_get_invalid_identifiers(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + row = await queries_invalid_identifiers.get_invalid_identifiers(conn=psycopg_async_conn, id_=INVALID_IDENTIFIER_ID) + assert row is not None + assert row.column_3p_ == "3%" + assert row.new_notes == "hello" + assert row.column__pct is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_invalid_identifiers"]) + async def test_get_invalid_identifiers_not_found(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries_invalid_identifiers.get_invalid_identifiers(conn=psycopg_async_conn, id_=INVALID_IDENTIFIER_ID - 1) is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::insert_third_party_stat") + async def test_insert_third_party_stat(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries_invalid_identifiers.insert_third_party_stat(conn=psycopg_async_conn, id_=INVALID_IDENTIFIER_ID, total=7) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_third_party_stat"]) + async def test_get_third_party_stat(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + stat = await queries_invalid_identifiers.get_third_party_stat(conn=psycopg_async_conn, id_=INVALID_IDENTIFIER_ID) + assert stat is not None + assert isinstance(stat, models.Model3RdPartyStat) + assert stat.total == 7 # ruff:ignore[magic-value-comparison] + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_third_party_stat"]) + async def test_get_third_party_stat_not_found(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries_invalid_identifiers.get_third_party_stat(conn=psycopg_async_conn, id_=INVALID_IDENTIFIER_ID - 1) is None + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::insert_enum") + async def test_insert_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries.insert_one_test_enum_type(conn=psycopg_async_conn, id_=510004, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::get_enum", depends=["TestDataclassFunctions::insert_enum"]) + async def test_get_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=510004) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::get_enum_value", depends=["TestDataclassFunctions::get_enum"]) + async def test_get_enum_value(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=510004) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum"]) + async def test_get_enum_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum"]) + async def test_get_enum_value_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::get_many_enums", depends=["TestDataclassFunctions::get_enum_value"]) + async def test_get_many_enums(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_many_test_enum_types(conn=psycopg_async_conn) + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_many_enums"]) + async def test_delete_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries.delete_one_test_enum_type(conn=psycopg_async_conn, id_=510004) == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::insert_enum_override") + async def test_insert_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override.insert_enum_override(conn=psycopg_async_conn, id_=520004, mood_test="happy") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum_override"]) + async def test_get_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=520004) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum_override"]) + async def test_get_enum_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::list_enum_override", depends=["TestDataclassFunctions::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[520004]) + assert len(rows) == 1 + assert rows[0].mood_test == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[520004]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path. + async with psycopg_async_conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520004: "happy"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::count_enum_override", depends=["TestDataclassFunctions::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + count = await queries_enum_override.count_enum_override_by_moods(conn=psycopg_async_conn, dollar_1=[enums.TestMood.HAPPY, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + count = await queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::count_enum_override"]) + async def test_delete_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # count_enum_override_by_moods asserts exact counts; remove the row so + # later suites against the shared database start clean. + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520004}) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::insert_converted") + async def test_insert_converted(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries_converters.insert_converted( + conn=psycopg_async_conn, + id_=CONVERTER_ID, + prefs=converters.Preferences(theme="dark", notifications=True), + maybe_prefs=None, + tags=frozenset({"b", "a"}), + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converted"]) + async def test_get_converted(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + row = await queries_converters.get_converted(conn=psycopg_async_conn, id_=CONVERTER_ID) + assert row is not None + assert row.prefs == converters.Preferences(theme="dark", notifications=True) + # The plugin guards None, so the converter never sees it. + assert row.maybe_prefs is None + assert row.tags == frozenset({"a", "b"}) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converted"]) + async def test_get_converted_not_found(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries_converters.get_converted(conn=psycopg_async_conn, id_=CONVERTER_ID + 999) is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::converted_nullable", depends=["TestDataclassFunctions::insert_converted"]) + async def test_converted_nullable_roundtrip(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries_converters.insert_converted( + conn=psycopg_async_conn, + id_=CONVERTER_ID + 1, + prefs=converters.Preferences(theme="light", notifications=False), + maybe_prefs=converters.Preferences(theme="sepia", notifications=True), + tags=frozenset(), + ) + row = await queries_converters.get_converted(conn=psycopg_async_conn, id_=CONVERTER_ID + 1) + assert row is not None + assert row.maybe_prefs == converters.Preferences(theme="sepia", notifications=True) + assert row.tags == frozenset() + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::list_converted", depends=["TestDataclassFunctions::insert_converted"]) + async def test_list_converted_by_tags(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # The converted value is passed as a QueryResults argument. + rows = await queries_converters.list_converted_by_tags(conn=psycopg_async_conn, tags=frozenset({"a", "b"})) + assert rows == [CONVERTER_ID] + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::iterate_converted", depends=["TestDataclassFunctions::insert_converted"]) + async def test_iterate_converted_by_tags(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + results = queries_converters.list_converted_by_tags(conn=psycopg_async_conn, tags=frozenset({"a", "b"})) + # Exercise the cursor-based async-for path. + async with psycopg_async_conn.transaction(): + seen = [row async for row in results] + assert seen == [CONVERTER_ID] + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::converted_nullable", "TestDataclassFunctions::list_converted", "TestDataclassFunctions::iterate_converted"]) + async def test_delete_converted(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries_converters.delete_converted(conn=psycopg_async_conn, id_=CONVERTER_ID) + await queries_converters.delete_converted(conn=psycopg_async_conn, id_=CONVERTER_ID + 1) + assert await queries_converters.get_converted(conn=psycopg_async_conn, id_=CONVERTER_ID) is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestDataclassFunctions::insert_converter_array") + async def test_insert_converter_array(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # db_type converter on a domain-typed column: the scalar label converts via to_db. + await queries_converters.insert_converter_array_row(conn=psycopg_async_conn, id_=CONVERTER_ARRAY_ID, label=pathlib.PurePosixPath("a/b")) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converter_array"]) + async def test_get_converter_array_label(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + label = await queries_converters.get_converter_array_label(conn=psycopg_async_conn, id_=CONVERTER_ARRAY_ID) + assert label == pathlib.PurePosixPath("a/b") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converter_array"]) + async def test_get_converter_array_label_not_found(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries_converters.get_converter_array_label(conn=psycopg_async_conn, id_=CONVERTER_ARRAY_ID + 999) is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converter_array"]) + async def test_find_converter_array_by_labels(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # Every element of the ANY($1::converter_label[]) array passes through + # the db_type converter before reaching the driver. + rows = await queries_converters.find_converter_array_by_labels( + conn=psycopg_async_conn, + dollar_1=[pathlib.PurePosixPath("a/b"), pathlib.PurePosixPath("c/d")], + ) + assert rows == [CONVERTER_ARRAY_ID] diff --git a/test/driver_psycopg_async/msgspec/__init__.py b/test/driver_psycopg_async/msgspec/__init__.py new file mode 100644 index 00000000..242b9d5f --- /dev/null +++ b/test/driver_psycopg_async/msgspec/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""Package to allow importing for psycopg tests.""" diff --git a/test/driver_psycopg_async/msgspec/classes/__init__.py b/test/driver_psycopg_async/msgspec/classes/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/msgspec/classes/enums.py b/test/driver_psycopg_async/msgspec/classes/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/msgspec/classes/models.py b/test/driver_psycopg_async/msgspec/classes/models.py new file mode 100644 index 00000000..ca7111f2 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/models.py @@ -0,0 +1,267 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +import msgspec +import typing + +if typing.TYPE_CHECKING: + from collections import UserString + from test.driver_psycopg_async.msgspec.classes import enums + import collections.abc + import datetime + import decimal + import uuid + + +class Model3RdPartyStat(msgspec.Struct): + """Model representing Model3RdPartyStat. + + Attributes: + id_ -- int + total -- int + """ + + id_: int + total: int + + +class TestEnumOverride(msgspec.Struct): + """Model representing TestEnumOverride. + + Attributes: + id_ -- int + mood_test -- str + """ + + id_: int + mood_test: str + + +class TestEnumType(msgspec.Struct): + """Model representing TestEnumType. + + Attributes: + id_ -- int + mood -- enums.TestMood + maybe_mood -- enums.TestMood | None + """ + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +class TestFieldNaming(msgspec.Struct): + """Model representing TestFieldNaming. + + Attributes: + id_ -- int + outputs -- str + """ + + id_: int + outputs: str + + +class TestInnerPostgresType(msgspec.Struct): + """Model representing TestInnerPostgresType. + + Attributes: + table_id -- int + serial_test -- int | None + serial4_test -- int | None + bigserial_test -- int | None + smallserial_test -- int | None + int_test -- int | None + bigint_test -- int | None + smallint_test -- int | None + float_test -- float | None + double_precision_test -- float | None + real_test -- float | None + numeric_test -- decimal.Decimal | None + money_test -- str | None + bool_test -- bool | None + json_test -- str | None + jsonb_test -- str | None + bytea_test -- memoryview | None + date_test -- datetime.date | None + time_test -- datetime.time | None + timetz_test -- datetime.time | None + timestamp_test -- datetime.datetime | None + timestamptz_test -- datetime.datetime | None + interval_test -- datetime.timedelta | None + text_test -- str | None + varchar_test -- str | None + bpchar_test -- str | None + char_test -- str | None + citext_test -- str | None + uuid_test -- uuid.UUID | None + inet_test -- str | None + cidr_test -- str | None + macaddr_test -- str | None + macaddr8_test -- str | None + ltree_test -- str | None + lquery_test -- str | None + ltxtquery_test -- str | None + """ + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +class TestInvalidIdentifier(msgspec.Struct): + """Model representing TestInvalidIdentifier. + + Attributes: + id_ -- int + column_3p_ -- str | None + new_notes -- str + column__pct -- str | None + """ + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +class TestPostgresType(msgspec.Struct): + """Model representing TestPostgresType. + + Attributes: + id_ -- int + serial_test -- int + serial4_test -- int + bigserial_test -- int + smallserial_test -- int + int_test -- int + bigint_test -- int + smallint_test -- int + float_test -- float + double_precision_test -- float + real_test -- float + numeric_test -- decimal.Decimal + money_test -- str + bool_test -- bool + json_test -- str + jsonb_test -- str + bytea_test -- memoryview + date_test -- datetime.date + time_test -- datetime.time + timetz_test -- datetime.time + timestamp_test -- datetime.datetime + timestamptz_test -- datetime.datetime + interval_test -- datetime.timedelta + text_test -- str + varchar_test -- str + bpchar_test -- str + char_test -- str + citext_test -- str + uuid_test -- uuid.UUID + inet_test -- str + cidr_test -- str + macaddr_test -- str + macaddr8_test -- str + ltree_test -- str + lquery_test -- str + ltxtquery_test -- str + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +class TestTypeOverride(msgspec.Struct): + """Model representing TestTypeOverride. + + Attributes: + id_ -- int + text_test -- UserString | None + """ + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/msgspec/classes/queries.py b/test/driver_psycopg_async/msgspec/classes/queries.py new file mode 100644 index 00000000..38cdd5eb --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/queries.py @@ -0,0 +1,2078 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "Queries", + "QueryResults", + "TestCopyFromParams", +) + +from collections import UserString +import msgspec +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import datetime + import decimal + import uuid + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.classes import enums +from test.driver_psycopg_async.msgspec.classes import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetEmbeddedTestPostgresTypeRow(msgspec.Struct): + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes: + id_ -- int + serial_test -- int + serial4_test -- int + bigserial_test -- int + smallserial_test -- int + int_test -- int + bigint_test -- int + smallint_test -- int + float_test -- float + double_precision_test -- float + real_test -- float + numeric_test -- decimal.Decimal + money_test -- str + bool_test -- bool + json_test -- str + jsonb_test -- str + bytea_test -- memoryview + date_test -- datetime.date + time_test -- datetime.time + timetz_test -- datetime.time + timestamp_test -- datetime.datetime + timestamptz_test -- datetime.datetime + interval_test -- datetime.timedelta + text_test -- str + varchar_test -- str + bpchar_test -- str + char_test -- str + citext_test -- str + uuid_test -- uuid.UUID + inet_test -- str + cidr_test -- str + macaddr_test -- str + macaddr8_test -- str + ltree_test -- str + lquery_test -- str + ltxtquery_test -- str + test_inner_postgres_type -- models.TestInnerPostgresType + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +class GetAllEmbeddedTestPostgresTypeRow(msgspec.Struct): + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes: + test_postgres_type -- models.TestPostgresType + test_inner_postgres_type -- models.TestInnerPostgresType + """ + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +class TestCopyFromParams(msgspec.Struct): + """Model representing TestCopyFromParams. + + Attributes: + id_ -- int + float_test -- float + int_test -- int + """ + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Arguments: + conn -- The connection object of type `ConnectionLike` used to execute queries. + sql -- The SQL statement that will be executed when fetching/iterating. + decode_hook -- A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params -- Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class Queries: + """Queries from file queries.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute queries. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + ConnectionLike -- Connection object used to make queries. + """ + return self._conn + + async def get_one_test_postgres_type(self, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + id_ -- int. + + Returns: + models.TestPostgresType -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_inner_test_postgres_type(self, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Arguments: + table_id -- int. + + Returns: + models.TestInnerPostgresType -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_test_timestamp_postgres_type(self, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + id_ -- int. + + Returns: + datetime.datetime -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + async def get_one_test_bytea_postgres_type(self, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + id_ -- int. + + Returns: + memoryview -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + def get_many_test_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + QueryResults[models.TestPostgresType] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_iterator_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + QueryResults[models.TestPostgresType] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_timestamp_postgres_type(self, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Arguments: + id_ -- int. + + Returns: + QueryResults[datetime.datetime] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(self._conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + def get_many_test_bytea_postgres_type(self, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Arguments: + id_ -- int. + + Returns: + QueryResults[memoryview] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(self._conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + async def get_embedded_test_postgres_type(self, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + GetEmbeddedTestPostgresTypeRow -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def get_all_embedded_test_postgres_type(self, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + GetAllEmbeddedTestPostgresTypeRow -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def create_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + id_ -- int. + serial_test -- int. + serial4_test -- int. + bigserial_test -- int. + smallserial_test -- int. + int_test -- int. + bigint_test -- int. + smallint_test -- int. + float_test -- float. + double_precision_test -- float. + real_test -- float. + numeric_test -- decimal.Decimal. + money_test -- str. + bool_test -- bool. + json_test -- str. + jsonb_test -- str. + bytea_test -- memoryview. + date_test -- datetime.date. + time_test -- datetime.time. + timetz_test -- datetime.time. + timestamp_test -- datetime.datetime. + timestamptz_test -- datetime.datetime. + interval_test -- datetime.timedelta. + text_test -- str. + varchar_test -- str. + bpchar_test -- str. + char_test -- str. + citext_test -- str. + uuid_test -- uuid.UUID. + inet_test -- str. + cidr_test -- str. + macaddr_test -- str. + macaddr8_test -- str. + ltree_test -- str. + lquery_test -- str. + ltxtquery_test -- str. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def create_one_test_postgres_inner_type( + self, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + table_id -- int. + serial_test -- int | None. + serial4_test -- int | None. + bigserial_test -- int | None. + smallserial_test -- int | None. + int_test -- int | None. + bigint_test -- int | None. + smallint_test -- int | None. + float_test -- float | None. + double_precision_test -- float | None. + real_test -- float | None. + numeric_test -- decimal.Decimal | None. + money_test -- str | None. + bool_test -- bool | None. + json_test -- str | None. + jsonb_test -- str | None. + bytea_test -- memoryview | None. + date_test -- datetime.date | None. + time_test -- datetime.time | None. + timetz_test -- datetime.time | None. + timestamp_test -- datetime.datetime | None. + timestamptz_test -- datetime.datetime | None. + interval_test -- datetime.timedelta | None. + text_test -- str | None. + varchar_test -- str | None. + bpchar_test -- str | None. + char_test -- str | None. + citext_test -- str | None. + uuid_test -- uuid.UUID | None. + inet_test -- str | None. + cidr_test -- str | None. + macaddr_test -- str | None. + macaddr8_test -- str | None. + ltree_test -- str | None. + lquery_test -- str | None. + ltxtquery_test -- str | None. + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + async def delete_one_test_postgres_type(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + id_ -- int. + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_test_postgres_inner_type(self, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Arguments: + table_id -- int. + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + async def create_result_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + id_ -- int. + serial_test -- int. + serial4_test -- int. + bigserial_test -- int. + smallserial_test -- int. + int_test -- int. + bigint_test -- int. + smallint_test -- int. + float_test -- float. + double_precision_test -- float. + real_test -- float. + numeric_test -- decimal.Decimal. + money_test -- str. + bool_test -- bool. + json_test -- str. + jsonb_test -- str. + bytea_test -- memoryview. + date_test -- datetime.date. + time_test -- datetime.time. + timetz_test -- datetime.time. + timestamp_test -- datetime.datetime. + timestamptz_test -- datetime.datetime. + interval_test -- datetime.timedelta. + text_test -- str. + varchar_test -- str. + bpchar_test -- str. + char_test -- str. + citext_test -- str. + uuid_test -- uuid.UUID. + inet_test -- str. + cidr_test -- str. + macaddr_test -- str. + macaddr8_test -- str. + ltree_test -- str. + lquery_test -- str. + ltxtquery_test -- str. + + Returns: + psycopg.AsyncCursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def update_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + psycopg.AsyncCursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return await self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + psycopg.AsyncCursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return await self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def create_rows_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + id_ -- int. + serial_test -- int. + serial4_test -- int. + bigserial_test -- int. + smallserial_test -- int. + int_test -- int. + bigint_test -- int. + smallint_test -- int. + float_test -- float. + double_precision_test -- float. + real_test -- float. + numeric_test -- decimal.Decimal. + money_test -- str. + bool_test -- bool. + json_test -- str. + jsonb_test -- str. + bytea_test -- memoryview. + date_test -- datetime.date. + time_test -- datetime.time. + timetz_test -- datetime.time. + timestamp_test -- datetime.datetime. + timestamptz_test -- datetime.datetime. + interval_test -- datetime.timedelta. + text_test -- str. + varchar_test -- str. + bpchar_test -- str. + char_test -- str. + citext_test -- str. + uuid_test -- uuid.UUID. + inet_test -- str. + cidr_test -- str. + macaddr_test -- str. + macaddr8_test -- str. + ltree_test -- str. + lquery_test -- str. + ltxtquery_test -- str. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + async def update_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def delete_one_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def create_rows_table(self) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + async def test_copy_from(self, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Arguments: + params -- collections.abc.Sequence[TestCopyFromParams]. A list of params for rows that should be inserted. + + Returns: + int -- The number of affected rows. + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + async def insert_type_override(self, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Arguments: + id_ -- int. + text_test -- UserString | None. + """ + await self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + async def get_one_type_override(self, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + models.TestTypeOverride -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + def get_many_type_override(self, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + QueryResults[models.TestTypeOverride] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(self._conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def get_one_text_type_override(self, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + UserString -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + def get_many_text_type_override(self, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + QueryResults[UserString | None] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(self._conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def delete_type_override(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + id_ -- int. + """ + await self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + async def insert_one_test_enum_type(self, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Arguments: + id_ -- int. + mood -- enums.TestMood. + maybe_mood -- enums.TestMood | None. + """ + await self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + async def get_one_test_enum_type(self, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + models.TestEnumType -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + async def get_one_test_enum_value(self, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + enums.TestMood -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + def get_many_test_enum_types(self) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Returns: + QueryResults[models.TestEnumType] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(self._conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + async def delete_one_test_enum_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/msgspec/classes/queries_copy_override.py b/test/driver_psycopg_async/msgspec/classes/queries_copy_override.py new file mode 100644 index 00000000..b0d45315 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/queries_copy_override.py @@ -0,0 +1,114 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "QueriesCopyOverride", +) + +import decimal +import msgspec +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +class CopyOverrideRowsParams(msgspec.Struct): + """Model representing CopyOverrideRowsParams. + + Attributes: + id_ -- int + amount -- float + co_l -- str + """ + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +class QueriesCopyOverride: + """Queries from file queries_copy_override.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute queries. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + ConnectionLike -- Connection object used to make queries. + """ + return self._conn + + async def copy_override_rows(self, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Arguments: + params -- collections.abc.Sequence[CopyOverrideRowsParams]. A list of params for rows that should be inserted. + + Returns: + int -- The number of affected rows. + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + async def count_copy_override_rows(self) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Returns: + int -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + async def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + await self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/msgspec/classes/queries_enum_override.py b/test/driver_psycopg_async/msgspec/classes/queries_enum_override.py new file mode 100644 index 00000000..8575eaf5 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/queries_enum_override.py @@ -0,0 +1,206 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueriesEnumOverride", + "QueryResults", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.classes import enums +from test.driver_psycopg_async.msgspec.classes import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Arguments: + conn -- The connection object of type `ConnectionLike` used to execute queries. + sql -- The SQL statement that will be executed when fetching/iterating. + decode_hook -- A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params -- Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class QueriesEnumOverride: + """Queries from file queries_enum_override.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute queries. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + ConnectionLike -- Connection object used to make queries. + """ + return self._conn + + async def insert_enum_override(self, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Arguments: + id_ -- int. + mood_test -- str. + """ + await self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + async def get_enum_override_mood(self, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + str -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + def list_enum_override_by_ids(self, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Arguments: + dollar_1 -- collections.abc.Sequence[int]. + + Returns: + QueryResults[models.TestEnumOverride] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(self._conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + async def count_enum_override_by_moods(self, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Arguments: + dollar_1 -- collections.abc.Sequence[enums.TestMood]. + + Returns: + int -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/msgspec/classes/queries_field_namings.py b/test/driver_psycopg_async/msgspec/classes/queries_field_namings.py new file mode 100644 index 00000000..c9bf2e28 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/queries_field_namings.py @@ -0,0 +1,141 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "QueriesFieldNamings", +) + +import msgspec +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.classes import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetJoinedFieldNamingsRow(msgspec.Struct): + """Model representing GetJoinedFieldNamingsRow. + + Attributes: + outputs -- str + outputs_2 -- str + """ + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +class QueriesFieldNamings: + """Queries from file queries_field_namings.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute queries. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + ConnectionLike -- Connection object used to make queries. + """ + return self._conn + + async def get_field_naming(self, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + id_ -- int. + + Returns: + models.TestFieldNaming -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + async def get_joined_field_namings(self, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Arguments: + id_ -- int. + + Returns: + GetJoinedFieldNamingsRow -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + async def set_field_naming_outputs(self, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Arguments: + id_ -- int. + outputs -- str. + outputs_2 -- str. + """ + await self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/msgspec/classes/queries_invalid_identifiers.py b/test/driver_psycopg_async/msgspec/classes/queries_invalid_identifiers.py new file mode 100644 index 00000000..1e898424 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/classes/queries_invalid_identifiers.py @@ -0,0 +1,124 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("QueriesInvalidIdentifiers",) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.classes import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +class QueriesInvalidIdentifiers: + """Queries from file queries_invalid_identifiers.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute queries. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + ConnectionLike -- Connection object used to make queries. + """ + return self._conn + + async def insert_invalid_identifiers(self, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Arguments: + id_ -- int. + column_3p_ -- str | None. + new_notes -- str. + """ + await self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + async def get_invalid_identifiers(self, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + models.TestInvalidIdentifier -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + async def insert_third_party_stat(self, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Arguments: + id_ -- int. + total -- int. + """ + await self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + async def get_third_party_stat(self, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Arguments: + id_ -- int. + + Returns: + models.Model3RdPartyStat -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/msgspec/functions/__init__.py b/test/driver_psycopg_async/msgspec/functions/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/msgspec/functions/enums.py b/test/driver_psycopg_async/msgspec/functions/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/msgspec/functions/models.py b/test/driver_psycopg_async/msgspec/functions/models.py new file mode 100644 index 00000000..e82d141e --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/models.py @@ -0,0 +1,267 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +import msgspec +import typing + +if typing.TYPE_CHECKING: + from collections import UserString + from test.driver_psycopg_async.msgspec.functions import enums + import collections.abc + import datetime + import decimal + import uuid + + +class Model3RdPartyStat(msgspec.Struct): + """Model representing Model3RdPartyStat. + + Attributes: + id_ -- int + total -- int + """ + + id_: int + total: int + + +class TestEnumOverride(msgspec.Struct): + """Model representing TestEnumOverride. + + Attributes: + id_ -- int + mood_test -- str + """ + + id_: int + mood_test: str + + +class TestEnumType(msgspec.Struct): + """Model representing TestEnumType. + + Attributes: + id_ -- int + mood -- enums.TestMood + maybe_mood -- enums.TestMood | None + """ + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +class TestFieldNaming(msgspec.Struct): + """Model representing TestFieldNaming. + + Attributes: + id_ -- int + outputs -- str + """ + + id_: int + outputs: str + + +class TestInnerPostgresType(msgspec.Struct): + """Model representing TestInnerPostgresType. + + Attributes: + table_id -- int + serial_test -- int | None + serial4_test -- int | None + bigserial_test -- int | None + smallserial_test -- int | None + int_test -- int | None + bigint_test -- int | None + smallint_test -- int | None + float_test -- float | None + double_precision_test -- float | None + real_test -- float | None + numeric_test -- decimal.Decimal | None + money_test -- str | None + bool_test -- bool | None + json_test -- str | None + jsonb_test -- str | None + bytea_test -- memoryview | None + date_test -- datetime.date | None + time_test -- datetime.time | None + timetz_test -- datetime.time | None + timestamp_test -- datetime.datetime | None + timestamptz_test -- datetime.datetime | None + interval_test -- datetime.timedelta | None + text_test -- str | None + varchar_test -- str | None + bpchar_test -- str | None + char_test -- str | None + citext_test -- str | None + uuid_test -- uuid.UUID | None + inet_test -- str | None + cidr_test -- str | None + macaddr_test -- str | None + macaddr8_test -- str | None + ltree_test -- str | None + lquery_test -- str | None + ltxtquery_test -- str | None + """ + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +class TestInvalidIdentifier(msgspec.Struct): + """Model representing TestInvalidIdentifier. + + Attributes: + id_ -- int + column_3p_ -- str | None + new_notes -- str + column__pct -- str | None + """ + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +class TestPostgresType(msgspec.Struct): + """Model representing TestPostgresType. + + Attributes: + id_ -- int + serial_test -- int + serial4_test -- int + bigserial_test -- int + smallserial_test -- int + int_test -- int + bigint_test -- int + smallint_test -- int + float_test -- float + double_precision_test -- float + real_test -- float + numeric_test -- decimal.Decimal + money_test -- str + bool_test -- bool + json_test -- str + jsonb_test -- str + bytea_test -- memoryview + date_test -- datetime.date + time_test -- datetime.time + timetz_test -- datetime.time + timestamp_test -- datetime.datetime + timestamptz_test -- datetime.datetime + interval_test -- datetime.timedelta + text_test -- str + varchar_test -- str + bpchar_test -- str + char_test -- str + citext_test -- str + uuid_test -- uuid.UUID + inet_test -- str + cidr_test -- str + macaddr_test -- str + macaddr8_test -- str + ltree_test -- str + lquery_test -- str + ltxtquery_test -- str + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +class TestTypeOverride(msgspec.Struct): + """Model representing TestTypeOverride. + + Attributes: + id_ -- int + text_test -- UserString | None + """ + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/msgspec/functions/queries.py b/test/driver_psycopg_async/msgspec/functions/queries.py new file mode 100644 index 00000000..80dcb332 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/queries.py @@ -0,0 +1,2157 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "QueryResults", + "TestCopyFromParams", + "create_one_test_postgres_inner_type", + "create_one_test_postgres_type", + "create_result_one_test_postgres_type", + "create_rows_one_test_postgres_type", + "create_rows_table", + "delete_one_result_test_postgres_type", + "delete_one_rows_test_postgres_type", + "delete_one_test_enum_type", + "delete_one_test_postgres_inner_type", + "delete_one_test_postgres_type", + "delete_type_override", + "get_all_embedded_test_postgres_type", + "get_embedded_test_postgres_type", + "get_many_test_bytea_postgres_type", + "get_many_test_enum_types", + "get_many_test_iterator_postgres_type", + "get_many_test_postgres_type", + "get_many_test_timestamp_postgres_type", + "get_many_text_type_override", + "get_many_type_override", + "get_one_inner_test_postgres_type", + "get_one_test_bytea_postgres_type", + "get_one_test_enum_type", + "get_one_test_enum_value", + "get_one_test_postgres_type", + "get_one_test_timestamp_postgres_type", + "get_one_text_type_override", + "get_one_type_override", + "insert_one_test_enum_type", + "insert_type_override", + "test_copy_from", + "update_result_test_postgres_type", + "update_rows_test_postgres_type", +) + +from collections import UserString +import msgspec +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import datetime + import decimal + import uuid + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.functions import enums +from test.driver_psycopg_async.msgspec.functions import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetEmbeddedTestPostgresTypeRow(msgspec.Struct): + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes: + id_ -- int + serial_test -- int + serial4_test -- int + bigserial_test -- int + smallserial_test -- int + int_test -- int + bigint_test -- int + smallint_test -- int + float_test -- float + double_precision_test -- float + real_test -- float + numeric_test -- decimal.Decimal + money_test -- str + bool_test -- bool + json_test -- str + jsonb_test -- str + bytea_test -- memoryview + date_test -- datetime.date + time_test -- datetime.time + timetz_test -- datetime.time + timestamp_test -- datetime.datetime + timestamptz_test -- datetime.datetime + interval_test -- datetime.timedelta + text_test -- str + varchar_test -- str + bpchar_test -- str + char_test -- str + citext_test -- str + uuid_test -- uuid.UUID + inet_test -- str + cidr_test -- str + macaddr_test -- str + macaddr8_test -- str + ltree_test -- str + lquery_test -- str + ltxtquery_test -- str + test_inner_postgres_type -- models.TestInnerPostgresType + """ + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +class GetAllEmbeddedTestPostgresTypeRow(msgspec.Struct): + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes: + test_postgres_type -- models.TestPostgresType + test_inner_postgres_type -- models.TestInnerPostgresType + """ + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +class TestCopyFromParams(msgspec.Struct): + """Model representing TestCopyFromParams. + + Attributes: + id_ -- int + float_test -- float + int_test -- int + """ + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Arguments: + conn -- The connection object of type `ConnectionLike` used to execute queries. + sql -- The SQL statement that will be executed when fetching/iterating. + decode_hook -- A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params -- Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def get_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + models.TestPostgresType -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_inner_test_postgres_type(conn: ConnectionLike, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + table_id -- int. + + Returns: + models.TestInnerPostgresType -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + datetime.datetime -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + +async def get_one_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + memoryview -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + +def get_many_test_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + QueryResults[models.TestPostgresType] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_iterator_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + QueryResults[models.TestPostgresType] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + QueryResults[datetime.datetime] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + +def get_many_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + QueryResults[memoryview] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +async def get_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + GetEmbeddedTestPostgresTypeRow -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def get_all_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + GetAllEmbeddedTestPostgresTypeRow -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def create_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + serial_test -- int. + serial4_test -- int. + bigserial_test -- int. + smallserial_test -- int. + int_test -- int. + bigint_test -- int. + smallint_test -- int. + float_test -- float. + double_precision_test -- float. + real_test -- float. + numeric_test -- decimal.Decimal. + money_test -- str. + bool_test -- bool. + json_test -- str. + jsonb_test -- str. + bytea_test -- memoryview. + date_test -- datetime.date. + time_test -- datetime.time. + timetz_test -- datetime.time. + timestamp_test -- datetime.datetime. + timestamptz_test -- datetime.datetime. + interval_test -- datetime.timedelta. + text_test -- str. + varchar_test -- str. + bpchar_test -- str. + char_test -- str. + citext_test -- str. + uuid_test -- uuid.UUID. + inet_test -- str. + cidr_test -- str. + macaddr_test -- str. + macaddr8_test -- str. + ltree_test -- str. + lquery_test -- str. + ltxtquery_test -- str. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def create_one_test_postgres_inner_type( + conn: ConnectionLike, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + table_id -- int. + serial_test -- int | None. + serial4_test -- int | None. + bigserial_test -- int | None. + smallserial_test -- int | None. + int_test -- int | None. + bigint_test -- int | None. + smallint_test -- int | None. + float_test -- float | None. + double_precision_test -- float | None. + real_test -- float | None. + numeric_test -- decimal.Decimal | None. + money_test -- str | None. + bool_test -- bool | None. + json_test -- str | None. + jsonb_test -- str | None. + bytea_test -- memoryview | None. + date_test -- datetime.date | None. + time_test -- datetime.time | None. + timetz_test -- datetime.time | None. + timestamp_test -- datetime.datetime | None. + timestamptz_test -- datetime.datetime | None. + interval_test -- datetime.timedelta | None. + text_test -- str | None. + varchar_test -- str | None. + bpchar_test -- str | None. + char_test -- str | None. + citext_test -- str | None. + uuid_test -- uuid.UUID | None. + inet_test -- str | None. + cidr_test -- str | None. + macaddr_test -- str | None. + macaddr8_test -- str | None. + ltree_test -- str | None. + lquery_test -- str | None. + ltxtquery_test -- str | None. + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +async def delete_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_test_postgres_inner_type(conn: ConnectionLike, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + table_id -- int. + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +async def create_result_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + serial_test -- int. + serial4_test -- int. + bigserial_test -- int. + smallserial_test -- int. + int_test -- int. + bigint_test -- int. + smallint_test -- int. + float_test -- float. + double_precision_test -- float. + real_test -- float. + numeric_test -- decimal.Decimal. + money_test -- str. + bool_test -- bool. + json_test -- str. + jsonb_test -- str. + bytea_test -- memoryview. + date_test -- datetime.date. + time_test -- datetime.time. + timetz_test -- datetime.time. + timestamp_test -- datetime.datetime. + timestamptz_test -- datetime.datetime. + interval_test -- datetime.timedelta. + text_test -- str. + varchar_test -- str. + bpchar_test -- str. + char_test -- str. + citext_test -- str. + uuid_test -- uuid.UUID. + inet_test -- str. + cidr_test -- str. + macaddr_test -- str. + macaddr8_test -- str. + ltree_test -- str. + lquery_test -- str. + ltxtquery_test -- str. + + Returns: + psycopg.AsyncCursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + psycopg.AsyncCursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return await conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + psycopg.AsyncCursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return await conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def create_rows_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + serial_test -- int. + serial4_test -- int. + bigserial_test -- int. + smallserial_test -- int. + int_test -- int. + bigint_test -- int. + smallint_test -- int. + float_test -- float. + double_precision_test -- float. + real_test -- float. + numeric_test -- decimal.Decimal. + money_test -- str. + bool_test -- bool. + json_test -- str. + jsonb_test -- str. + bytea_test -- memoryview. + date_test -- datetime.date. + time_test -- datetime.time. + timetz_test -- datetime.time. + timestamp_test -- datetime.datetime. + timestamptz_test -- datetime.datetime. + interval_test -- datetime.timedelta. + text_test -- str. + varchar_test -- str. + bpchar_test -- str. + char_test -- str. + citext_test -- str. + uuid_test -- uuid.UUID. + inet_test -- str. + cidr_test -- str. + macaddr_test -- str. + macaddr8_test -- str. + ltree_test -- str. + lquery_test -- str. + ltxtquery_test -- str. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +async def update_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def delete_one_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def create_rows_table(conn: ConnectionLike) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + params -- collections.abc.Sequence[TestCopyFromParams]. A list of params for rows that should be inserted. + + Returns: + int -- The number of affected rows. + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +async def insert_type_override(conn: ConnectionLike, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + text_test -- UserString | None. + """ + await conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +async def get_one_type_override(conn: ConnectionLike, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + models.TestTypeOverride -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + +def get_many_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + QueryResults[models.TestTypeOverride] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def get_one_text_type_override(conn: ConnectionLike, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + UserString -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + +def get_many_text_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + QueryResults[UserString | None] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def delete_type_override(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + """ + await conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +async def insert_one_test_enum_type(conn: ConnectionLike, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + mood -- enums.TestMood. + maybe_mood -- enums.TestMood | None. + """ + await conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +async def get_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + models.TestEnumType -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + +async def get_one_test_enum_value(conn: ConnectionLike, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + enums.TestMood -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + +def get_many_test_enum_types(conn: ConnectionLike) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + + Returns: + QueryResults[models.TestEnumType] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + +async def delete_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + int -- The number of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/msgspec/functions/queries_copy_override.py b/test/driver_psycopg_async/msgspec/functions/queries_copy_override.py new file mode 100644 index 00000000..486e96aa --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/queries_copy_override.py @@ -0,0 +1,102 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "copy_override_rows", + "count_copy_override_rows", + "delete_copy_override_rows", +) + +import decimal +import msgspec +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +class CopyOverrideRowsParams(msgspec.Struct): + """Model representing CopyOverrideRowsParams. + + Attributes: + id_ -- int + amount -- float + co_l -- str + """ + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +async def copy_override_rows(conn: ConnectionLike, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + params -- collections.abc.Sequence[CopyOverrideRowsParams]. A list of params for rows that should be inserted. + + Returns: + int -- The number of affected rows. + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +async def count_copy_override_rows(conn: ConnectionLike) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + + Returns: + int -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + +async def delete_copy_override_rows(conn: ConnectionLike) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + """ + await conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/msgspec/functions/queries_enum_override.py b/test/driver_psycopg_async/msgspec/functions/queries_enum_override.py new file mode 100644 index 00000000..4dd3d2c8 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/queries_enum_override.py @@ -0,0 +1,194 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueryResults", + "count_enum_override_by_moods", + "get_enum_override_mood", + "insert_enum_override", + "list_enum_override_by_ids", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.functions import enums +from test.driver_psycopg_async.msgspec.functions import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Arguments: + conn -- The connection object of type `ConnectionLike` used to execute queries. + sql -- The SQL statement that will be executed when fetching/iterating. + decode_hook -- A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params -- Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def insert_enum_override(conn: ConnectionLike, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + mood_test -- str. + """ + await conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +async def get_enum_override_mood(conn: ConnectionLike, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + str -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + +def list_enum_override_by_ids(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + dollar_1 -- collections.abc.Sequence[int]. + + Returns: + QueryResults[models.TestEnumOverride] -- Helper class that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + +async def count_enum_override_by_moods(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + dollar_1 -- collections.abc.Sequence[enums.TestMood]. + + Returns: + int -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/msgspec/functions/queries_field_namings.py b/test/driver_psycopg_async/msgspec/functions/queries_field_namings.py new file mode 100644 index 00000000..38c68613 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/queries_field_namings.py @@ -0,0 +1,126 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "get_field_naming", + "get_joined_field_namings", + "set_field_naming_outputs", +) + +import msgspec +import psycopg +import psycopg.rows +import psycopg.types.string +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.functions import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetJoinedFieldNamingsRow(msgspec.Struct): + """Model representing GetJoinedFieldNamingsRow. + + Attributes: + outputs -- str + outputs_2 -- str + """ + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +async def get_field_naming(conn: ConnectionLike, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + models.TestFieldNaming -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +async def get_joined_field_namings(conn: ConnectionLike, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + GetJoinedFieldNamingsRow -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +async def set_field_naming_outputs(conn: ConnectionLike, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + outputs -- str. + outputs_2 -- str. + """ + await conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/msgspec/functions/queries_invalid_identifiers.py b/test/driver_psycopg_async/msgspec/functions/queries_invalid_identifiers.py new file mode 100644 index 00000000..621b7a73 --- /dev/null +++ b/test/driver_psycopg_async/msgspec/functions/queries_invalid_identifiers.py @@ -0,0 +1,114 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "get_invalid_identifiers", + "get_third_party_stat", + "insert_invalid_identifiers", + "insert_third_party_stat", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.msgspec.functions import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +async def insert_invalid_identifiers(conn: ConnectionLike, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + column_3p_ -- str | None. + new_notes -- str. + """ + await conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +async def get_invalid_identifiers(conn: ConnectionLike, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + models.TestInvalidIdentifier -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + +async def insert_third_party_stat(conn: ConnectionLike, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + total -- int. + """ + await conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +async def get_third_party_stat(conn: ConnectionLike, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Arguments: + conn -- Connection object of type `ConnectionLike` used to execute the query. + id_ -- int. + + Returns: + models.Model3RdPartyStat -- Result fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/msgspec/ruff.toml b/test/driver_psycopg_async/msgspec/ruff.toml new file mode 100644 index 00000000..876ccf0c --- /dev/null +++ b/test/driver_psycopg_async/msgspec/ruff.toml @@ -0,0 +1,5 @@ +extend="../../../ruff.toml" + + +[lint.pydocstyle] +convention = "pep257" \ No newline at end of file diff --git a/test/driver_psycopg_async/msgspec/test_psycopg_msgspec_classes.py b/test/driver_psycopg_async/msgspec/test_psycopg_msgspec_classes.py new file mode 100644 index 00000000..3e314e0c --- /dev/null +++ b/test/driver_psycopg_async/msgspec/test_psycopg_msgspec_classes.py @@ -0,0 +1,839 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows + +import math + +import pytest +import pytest_asyncio + +from test.driver_psycopg_async.msgspec.classes import enums +from test.driver_psycopg_async.msgspec.classes import models +from test.driver_psycopg_async.msgspec.classes import queries +from test.driver_psycopg_async.msgspec.classes import queries_enum_override + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestMsgspecClasses: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_async_conn) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::create") + async def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + await queries_obj.create_one_test_postgres_type( + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::create_inner", depends=["TestMsgspecClasses::create"]) + async def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + await queries_obj.create_one_test_postgres_inner_type( + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::create_inner"], name="TestMsgspecClasses::get_one") + async def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=model.id_) + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one"], name="TestMsgspecClasses::get_one_none") + async def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one_none"], name="TestMsgspecClasses::get_one_inner") + async def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one_inner"], name="TestMsgspecClasses::get_one_inner_none") + async def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_one_inner_none"], + name="TestMsgspecClasses::get_one_timestamp", + ) + async def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one_timestamp"], name="TestMsgspecClasses::get_one_timestamp_none") + async def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_one_timestamp_none"], + name="TestMsgspecClasses::get_one_bytea", + ) + async def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one_bytea"], name="TestMsgspecClasses::get_one_bytea_none") + async def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one_bytea_none"], name="TestMsgspecClasses::get_many") + async def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_many"], name="TestMsgspecClasses::get_many_timestamp") + async def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_many_timestamp"], + name="TestMsgspecClasses::get_many_bytea", + ) + async def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_many_bytea"], name="TestMsgspecClasses::get_embedded") + async def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_embedded"], name="TestMsgspecClasses::get_embedded_none") + async def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_embedded_none"], + name="TestMsgspecClasses::get_all_embedded", + ) + async def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_all_embedded"], name="TestMsgspecClasses::get_all_embedded_none") + async def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_all_embedded_none"], + name="TestMsgspecClasses::get_many_iterator", + ) + async def test_get_many_iterator( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + results = queries_obj.get_many_test_iterator_postgres_type(id_=model.id_) + async with queries_obj.conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_many_iterator"], name="TestMsgspecClasses::delete") + async def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::delete"], name="TestMsgspecClasses::delete_inner") + async def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::create_result") + async def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_result_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::create_result"], name="TestMsgspecClasses::update_result") + async def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::update_result"], name="TestMsgspecClasses::delete_result") + async def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::create_rows") + async def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_rows_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::create_rows"], name="TestMsgspecClasses::update_rows") + async def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::update_rows"], name="TestMsgspecClasses::delete_rows") + async def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::delete_rows"], name="TestMsgspecClasses::copy_from") + async def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries_obj.test_copy_from(params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries_obj.create_rows_table() + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::insert_type_override", + ) + async def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_type_override", + depends=["TestMsgspecClasses::insert_type_override"], + ) + async def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_type_override_none", + depends=["TestMsgspecClasses::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::get_many_type_override", + depends=["TestMsgspecClasses::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_text_type_override", + depends=["TestMsgspecClasses::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_text_type_override_none", + depends=["TestMsgspecClasses::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::get_many_text_type_override", + depends=["TestMsgspecClasses::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_text_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecClasses::delete_type_override", + depends=["TestMsgspecClasses::get_many_text_type_override"], + ) + async def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.delete_type_override(id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::insert_enum") + async def test_insert_enum(self, queries_obj: queries.Queries) -> None: + await queries_obj.insert_one_test_enum_type(id_=510005, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::get_enum", depends=["TestMsgspecClasses::insert_enum"]) + async def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=510005) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::get_enum_value", depends=["TestMsgspecClasses::get_enum"]) + async def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=510005) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum"]) + async def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum"]) + async def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::get_many_enums", depends=["TestMsgspecClasses::get_enum_value"]) + async def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_many_test_enum_types() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_many_enums"]) + async def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert await queries_obj.delete_one_test_enum_type(id_=510005) == 1 + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_enum_override_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_async_conn) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::insert_enum_override") + async def test_insert_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override_obj.insert_enum_override(id_=520005, mood_test="sad") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum_override"]) + async def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=520005) + assert mood is not None + assert isinstance(mood, str) + assert mood == "sad" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum_override"]) + async def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::list_enum_override", depends=["TestMsgspecClasses::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520005]) + assert len(rows) == 1 + assert rows[0].mood_test == "sad" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + results = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520005]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path; going through the conn + # property also covers its generated accessor. + async with queries_enum_override_obj.conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520005: "sad"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecClasses::count_enum_override", depends=["TestMsgspecClasses::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # No HAPPY in the list: other suites may leave happy rows behind and + # would break the exact count. + count = await queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.SAD, enums.TestMood.OK]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecClasses::count_enum_override"]) + async def test_cleanup_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520005}) + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = await no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.SAD]) + assert count is None diff --git a/test/driver_psycopg_async/msgspec/test_psycopg_msgspec_functions.py b/test/driver_psycopg_async/msgspec/test_psycopg_msgspec_functions.py new file mode 100644 index 00000000..93cb233b --- /dev/null +++ b/test/driver_psycopg_async/msgspec/test_psycopg_msgspec_functions.py @@ -0,0 +1,921 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows + +import math + +import pytest + +from test.driver_psycopg_async.msgspec.functions import enums +from test.driver_psycopg_async.msgspec.functions import models +from test.driver_psycopg_async.msgspec.functions import queries +from test.driver_psycopg_async.msgspec.functions import queries_copy_override +from test.driver_psycopg_async.msgspec.functions import queries_enum_override + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestMsgspecFunctions: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::create") + async def test_create( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.create_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::create2", depends=["TestMsgspecFunctions::create"]) + async def test_create_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.create_one_test_postgres_inner_type( + conn=psycopg_async_conn, + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::create2"], name="TestMsgspecFunctions::get_one") + async def test_get_one( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one"], name="TestMsgspecFunctions::get_one_none") + async def test_get_one_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_none"], name="TestMsgspecFunctions::get_one_inner") + async def test_get_one_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_inner"], name="TestMsgspecFunctions::get_one_inner_none") + async def test_get_one_inner_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_one_inner_none"], + name="TestMsgspecFunctions::get_one_timestamp", + ) + async def test_get_one_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_timestamp"], name="TestMsgspecFunctions::get_one_timestamp_none") + async def test_get_one_timestamp_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_one_timestamp_none"], + name="TestMsgspecFunctions::get_one_bytea", + ) + async def test_get_one_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_bytea"], name="TestMsgspecFunctions::get_one_bytea_none") + async def test_get_one_bytea_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_bytea_none"], name="TestMsgspecFunctions::get_many") + async def test_get_many( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_many"], + name="TestMsgspecFunctions::get_many_timestamp", + ) + async def test_get_many_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_many_timestamp"], + name="TestMsgspecFunctions::get_many_bytea", + ) + async def test_get_many_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_many_bytea"], + name="TestMsgspecFunctions::get_embedded", + ) + async def test_get_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_embedded"], name="TestMsgspecFunctions::get_embedded_none") + async def test_get_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_embedded_none"], + name="TestMsgspecFunctions::get_all_embedded", + ) + async def test_get_all_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_all_embedded"], + name="TestMsgspecFunctions::get_all_embedded_none", + ) + async def test_get_all_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_all_embedded_none"], + name="TestMsgspecFunctions::get_many_iterator", + ) + async def test_get_many_iterator( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_async_conn, id_=model.id_) + async with psycopg_async_conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_many_iterator"], name="TestMsgspecFunctions::delete") + async def test_delete( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.delete_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::delete"], name="TestMsgspecFunctions::delete_inner") + async def test_delete_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.delete_one_test_postgres_inner_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::create_result") + async def test_create_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_result_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::create_result"], name="TestMsgspecFunctions::update_result") + async def test_update_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::update_result"], name="TestMsgspecFunctions::delete_result") + async def test_delete_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::create_rows") + async def test_create_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_rows_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::create_rows"], name="TestMsgspecFunctions::update_rows") + async def test_update_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::update_rows"], name="TestMsgspecFunctions::delete_rows") + async def test_delete_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::delete_rows"], name="TestMsgspecFunctions::copy_from") + async def test_copy_from( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries.test_copy_from(conn=psycopg_async_conn, params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.create_rows_table(conn=psycopg_async_conn) + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::insert_type_override", + ) + async def test_insert_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.insert_type_override(conn=psycopg_async_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_type_override", + depends=["TestMsgspecFunctions::insert_type_override"], + ) + async def test_get_one_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_type_override_none", + depends=["TestMsgspecFunctions::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_many_type_override", + depends=["TestMsgspecFunctions::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_text_type_override", + depends=["TestMsgspecFunctions::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_text_type_override_none", + depends=["TestMsgspecFunctions::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_many_text_type_override", + depends=["TestMsgspecFunctions::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestMsgspecFunctions::delete_type_override", + depends=["TestMsgspecFunctions::get_many_text_type_override"], + ) + async def test_delete_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.delete_type_override(conn=psycopg_async_conn, id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::insert_enum") + async def test_insert_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries.insert_one_test_enum_type(conn=psycopg_async_conn, id_=424242, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::get_enum", depends=["TestMsgspecFunctions::insert_enum"]) + async def test_get_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=424242) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::get_enum_value", depends=["TestMsgspecFunctions::get_enum"]) + async def test_get_enum_value(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=424242) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum"]) + async def test_get_enum_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum"]) + async def test_get_enum_value_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::get_many_enums", depends=["TestMsgspecFunctions::get_enum_value"]) + async def test_get_many_enums(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_many_test_enum_types(conn=psycopg_async_conn) + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_many_enums"]) + async def test_delete_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries.delete_one_test_enum_type(conn=psycopg_async_conn, id_=424242) == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::insert_enum_override") + async def test_insert_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override.insert_enum_override(conn=psycopg_async_conn, id_=434343, mood_test="happy") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + async def test_get_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=434343) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + async def test_get_enum_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::list_enum_override", depends=["TestMsgspecFunctions::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[434343]) + assert len(rows) == 1 + assert rows[0].mood_test == "happy" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[434343]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path. + async with psycopg_async_conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {434343: "happy"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + async def test_list_enum_override_by_ids_empty(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + rows = await queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[987654321]) + assert rows == [] + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + count = await queries_enum_override.count_enum_override_by_moods(conn=psycopg_async_conn, dollar_1=[enums.TestMood.HAPPY, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_by_moods_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + count = await queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestMsgspecFunctions::copy_override") + async def test_copy_override_rows(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # The overridden float values must be converted back to Decimal before + # copy_records_to_table. + params = [ + queries_copy_override.CopyOverrideRowsParams(id_=1, amount=12.5, co_l="a"), + queries_copy_override.CopyOverrideRowsParams(id_=2, amount=0.25, co_l="b"), + ] + inserted = await queries_copy_override.copy_override_rows(conn=psycopg_async_conn, params=params) + assert inserted == len(params) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::copy_override"]) + async def test_count_and_delete_copy_override_rows(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + copied_rows = 2 + count = await queries_copy_override.count_copy_override_rows(conn=psycopg_async_conn) + assert count == copied_rows + await queries_copy_override.delete_copy_override_rows(conn=psycopg_async_conn) + count = await queries_copy_override.count_copy_override_rows(conn=psycopg_async_conn) + assert count == 0 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + async def test_delete_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # Later suites count test_enum_override rows by mood; drop this one. + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 434343}) + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_copy_override_rows_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + count = await queries_copy_override.count_copy_override_rows(conn=conn) + assert count is None diff --git a/test/driver_psycopg_async/omit_tc/__init__.py b/test/driver_psycopg_async/omit_tc/__init__.py new file mode 100644 index 00000000..d38d7fe9 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""Package to allow importing for psycopg omit_typechecking_block tests.""" diff --git a/test/driver_psycopg_async/omit_tc/classes/__init__.py b/test/driver_psycopg_async/omit_tc/classes/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/classes/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/omit_tc/classes/enums.py b/test/driver_psycopg_async/omit_tc/classes/enums.py new file mode 100644 index 00000000..0cfc74ec --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/classes/enums.py @@ -0,0 +1,22 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/omit_tc/classes/models.py b/test/driver_psycopg_async/omit_tc/classes/models.py new file mode 100644 index 00000000..62c9ced9 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/classes/models.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestEnumOverride",) + +import dataclasses +import collections.abc + + +@dataclasses.dataclass() +class TestEnumOverride: + """Model representing TestEnumOverride. + + Attributes: + id_: int + mood_test: str + """ + + id_: int + mood_test: str diff --git a/test/driver_psycopg_async/omit_tc/classes/queries_enum_override.py b/test/driver_psycopg_async/omit_tc/classes/queries_enum_override.py new file mode 100644 index 00000000..92a6d6e1 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/classes/queries_enum_override.py @@ -0,0 +1,210 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueriesEnumOverride", + "QueryResults", +) + +import typing +import collections.abc +import psycopg +import psycopg.rows + + +from test.driver_psycopg_async.omit_tc.classes import enums +from test.driver_psycopg_async.omit_tc.classes import models + +type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + +type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class QueriesEnumOverride: + """Queries from file queries_enum_override.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def insert_enum_override(self, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + id_: int. + mood_test: str. + """ + await self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + async def get_enum_override_mood(self, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `str` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + def list_enum_override_by_ids(self, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Args: + dollar_1: collections.abc.Sequence[int]. + + Returns: + Helper class of type `QueryResults[models.TestEnumOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(self._conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + async def count_enum_override_by_moods(self, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Args: + dollar_1: collections.abc.Sequence[enums.TestMood]. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/omit_tc/functions/__init__.py b/test/driver_psycopg_async/omit_tc/functions/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/functions/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/omit_tc/functions/enums.py b/test/driver_psycopg_async/omit_tc/functions/enums.py new file mode 100644 index 00000000..0cfc74ec --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/functions/enums.py @@ -0,0 +1,22 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/omit_tc/functions/models.py b/test/driver_psycopg_async/omit_tc/functions/models.py new file mode 100644 index 00000000..62c9ced9 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/functions/models.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestEnumOverride",) + +import dataclasses +import collections.abc + + +@dataclasses.dataclass() +class TestEnumOverride: + """Model representing TestEnumOverride. + + Attributes: + id_: int + mood_test: str + """ + + id_: int + mood_test: str diff --git a/test/driver_psycopg_async/omit_tc/functions/queries_enum_override.py b/test/driver_psycopg_async/omit_tc/functions/queries_enum_override.py new file mode 100644 index 00000000..fac34745 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/functions/queries_enum_override.py @@ -0,0 +1,201 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueryResults", + "count_enum_override_by_moods", + "get_enum_override_mood", + "insert_enum_override", + "list_enum_override_by_ids", +) + +import typing +import collections.abc +import psycopg +import psycopg.rows + + +from test.driver_psycopg_async.omit_tc.functions import enums +from test.driver_psycopg_async.omit_tc.functions import models + +type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + +type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def insert_enum_override(conn: ConnectionLike, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + mood_test: str. + """ + await conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +async def get_enum_override_mood(conn: ConnectionLike, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `str` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + +def list_enum_override_by_ids(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + dollar_1: collections.abc.Sequence[int]. + + Returns: + Helper class of type `QueryResults[models.TestEnumOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + +async def count_enum_override_by_moods(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + dollar_1: collections.abc.Sequence[enums.TestMood]. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/omit_tc/ruff.toml b/test/driver_psycopg_async/omit_tc/ruff.toml new file mode 100644 index 00000000..0fa548a4 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/ruff.toml @@ -0,0 +1,5 @@ +extend="../../../ruff.toml" + + +[lint.pydocstyle] +convention = "google" diff --git a/test/driver_psycopg_async/omit_tc/test_omit_typechecking_import.py b/test/driver_psycopg_async/omit_tc/test_omit_typechecking_import.py new file mode 100644 index 00000000..ec2bda4f --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/test_omit_typechecking_import.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""With omit_typechecking_block the driver hook executes at module level. + +Importing the generated modules is the whole test: the ConnectionLike and +QueryResultsArgsType aliases execute at module level, which the lazy PEP 695 +alias form must keep safe. +""" + +from __future__ import annotations + +from test.driver_psycopg_async.omit_tc.classes import queries_enum_override as classes_module +from test.driver_psycopg_async.omit_tc.functions import queries_enum_override as functions_module + + +def test_omit_typechecking_modules_import_at_runtime() -> None: + assert classes_module.INSERT_ENUM_OVERRIDE + assert functions_module.INSERT_ENUM_OVERRIDE diff --git a/test/driver_psycopg_async/omit_tc/test_omit_typechecking_runtime.py b/test/driver_psycopg_async/omit_tc/test_omit_typechecking_runtime.py new file mode 100644 index 00000000..b9532d52 --- /dev/null +++ b/test/driver_psycopg_async/omit_tc/test_omit_typechecking_runtime.py @@ -0,0 +1,203 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""Runtime coverage for the psycopg omit_typechecking_block query modules. + +The generated code must behave exactly like the regular variants even though +all imports and type aliases execute at module level. These tests exercise +the query functions and the QueryResults helper (both the await path and the +cursor-based async-for path) of the classes and functions packages. +""" + +from __future__ import annotations + +import asyncio +import typing + +import pytest +import pytest_asyncio + +from test.driver_psycopg_async.omit_tc.classes import enums as classes_enums +from test.driver_psycopg_async.omit_tc.classes import models as classes_models +from test.driver_psycopg_async.omit_tc.classes import queries_enum_override as classes_queries +from test.driver_psycopg_async.omit_tc.functions import enums as functions_enums +from test.driver_psycopg_async.omit_tc.functions import models as functions_models +from test.driver_psycopg_async.omit_tc.functions import queries_enum_override as functions_queries + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows + +# Ids reserved for this file; all suites share one database sequentially, so +# every enum_override chain uses unique ids and deletes its rows at the end. +CLASSES_IDS: typing.Final[tuple[int, int]] = (510010, 520010) +FUNCTIONS_IDS: typing.Final[tuple[int, int]] = (510011, 520011) +MISSING_ID: typing.Final[int] = 987654321 + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestOmitTcClasses: + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> classes_queries.QueriesEnumOverride: + return classes_queries.QueriesEnumOverride(conn=psycopg_async_conn) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcClasses::insert_enum_override") + async def test_insert_enum_override(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_obj.insert_enum_override(id_=CLASSES_IDS[0], mood_test="happy") + await queries_obj.insert_enum_override(id_=CLASSES_IDS[1], mood_test="sad") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcClasses::get_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + async def test_get_enum_override_mood(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + mood = await queries_obj.get_enum_override_mood(id_=CLASSES_IDS[0]) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.asyncio(loop_scope="session") + async def test_get_enum_override_mood_not_found(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + assert await queries_obj.get_enum_override_mood(id_=MISSING_ID) is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcClasses::list_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + # Awaiting the QueryResults object fetches all rows in one go. + rows = await queries_obj.list_enum_override_by_ids(dollar_1=list(CLASSES_IDS)) + assert all(isinstance(row, classes_models.TestEnumOverride) for row in rows) + assert {row.id_: row.mood_test for row in rows} == {CLASSES_IDS[0]: "happy", CLASSES_IDS[1]: "sad"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcClasses::iterate_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + async def test_iterate_enum_override_by_ids( + self, + queries_obj: classes_queries.QueriesEnumOverride, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + assert queries_obj.conn is psycopg_async_conn + results = queries_obj.list_enum_override_by_ids(dollar_1=list(CLASSES_IDS)) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path. + async with queries_obj.conn.transaction(): + async for row in results: + assert isinstance(row, classes_models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {CLASSES_IDS[0]: "happy", CLASSES_IDS[1]: "sad"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcClasses::count_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + count = await queries_obj.count_enum_override_by_moods(dollar_1=[classes_enums.TestMood.HAPPY, classes_enums.TestMood.SAD]) + assert count == len(CLASSES_IDS) + assert await queries_obj.count_enum_override_by_moods(dollar_1=[classes_enums.TestMood.VALUE_24H]) == 0 + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + stub_queries_obj = classes_queries.QueriesEnumOverride(conn=conn) + count = await stub_queries_obj.count_enum_override_by_moods(dollar_1=[classes_enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestOmitTcClasses::insert_enum_override"]) + async def test_delete_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # count_enum_override_by_moods asserts exact counts; remove the rows so + # later suites against the shared database start clean. + for row_id in CLASSES_IDS: + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": row_id}) + + +@pytest.mark.asyncio(loop_scope="session") +class TestOmitTcFunctions: + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcFunctions::insert_enum_override") + async def test_insert_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await functions_queries.insert_enum_override(conn=psycopg_async_conn, id_=FUNCTIONS_IDS[0], mood_test="happy") + await functions_queries.insert_enum_override(conn=psycopg_async_conn, id_=FUNCTIONS_IDS[1], mood_test="sad") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcFunctions::get_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + async def test_get_enum_override_mood(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await functions_queries.get_enum_override_mood(conn=psycopg_async_conn, id_=FUNCTIONS_IDS[0]) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.asyncio(loop_scope="session") + async def test_get_enum_override_mood_not_found(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await functions_queries.get_enum_override_mood(conn=psycopg_async_conn, id_=MISSING_ID) is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcFunctions::list_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # Awaiting the QueryResults object fetches all rows in one go. + rows = await functions_queries.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=list(FUNCTIONS_IDS)) + assert all(isinstance(row, functions_models.TestEnumOverride) for row in rows) + assert {row.id_: row.mood_test for row in rows} == {FUNCTIONS_IDS[0]: "happy", FUNCTIONS_IDS[1]: "sad"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcFunctions::iterate_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + results = functions_queries.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=list(FUNCTIONS_IDS)) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path. + async with psycopg_async_conn.transaction(): + async for row in results: + assert isinstance(row, functions_models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {FUNCTIONS_IDS[0]: "happy", FUNCTIONS_IDS[1]: "sad"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestOmitTcFunctions::count_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + count = await functions_queries.count_enum_override_by_moods(conn=psycopg_async_conn, dollar_1=[functions_enums.TestMood.HAPPY, functions_enums.TestMood.SAD]) + assert count == len(FUNCTIONS_IDS) + assert await functions_queries.count_enum_override_by_moods(conn=psycopg_async_conn, dollar_1=[functions_enums.TestMood.VALUE_24H]) == 0 + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + count = await functions_queries.count_enum_override_by_moods(conn=conn, dollar_1=[functions_enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestOmitTcFunctions::insert_enum_override"]) + async def test_delete_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # count_enum_override_by_moods asserts exact counts; remove the rows so + # later suites against the shared database start clean. + for row_id in FUNCTIONS_IDS: + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": row_id}) diff --git a/test/driver_psycopg_async/pydantic/__init__.py b/test/driver_psycopg_async/pydantic/__init__.py new file mode 100644 index 00000000..242b9d5f --- /dev/null +++ b/test/driver_psycopg_async/pydantic/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +"""Package to allow importing for psycopg tests.""" diff --git a/test/driver_psycopg_async/pydantic/classes/__init__.py b/test/driver_psycopg_async/pydantic/classes/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/pydantic/classes/enums.py b/test/driver_psycopg_async/pydantic/classes/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/pydantic/classes/models.py b/test/driver_psycopg_async/pydantic/classes/models.py new file mode 100644 index 00000000..0450247d --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/models.py @@ -0,0 +1,284 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +from collections import UserString +import datetime +import decimal +import pydantic +import typing +import uuid + +if typing.TYPE_CHECKING: + import collections.abc + +from test.driver_psycopg_async.pydantic.classes import enums + + +class Model3RdPartyStat(pydantic.BaseModel): + """Model representing Model3RdPartyStat. + + Attributes: + id_: int + total: int + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + total: int + + +class TestEnumOverride(pydantic.BaseModel): + """Model representing TestEnumOverride. + + Attributes: + id_: int + mood_test: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + mood_test: str + + +class TestEnumType(pydantic.BaseModel): + """Model representing TestEnumType. + + Attributes: + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +class TestFieldNaming(pydantic.BaseModel): + """Model representing TestFieldNaming. + + Attributes: + id_: int + outputs: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + outputs: str + + +class TestInnerPostgresType(pydantic.BaseModel): + """Model representing TestInnerPostgresType. + + Attributes: + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +class TestInvalidIdentifier(pydantic.BaseModel): + """Model representing TestInvalidIdentifier. + + Attributes: + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +class TestPostgresType(pydantic.BaseModel): + """Model representing TestPostgresType. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +class TestTypeOverride(pydantic.BaseModel): + """Model representing TestTypeOverride. + + Attributes: + id_: int + text_test: UserString | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/pydantic/classes/queries.py b/test/driver_psycopg_async/pydantic/classes/queries.py new file mode 100644 index 00000000..90718e12 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/queries.py @@ -0,0 +1,2090 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "Queries", + "QueryResults", + "TestCopyFromParams", +) + +from collections import UserString +import datetime +import decimal +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import pydantic +import typing +import uuid + +if typing.TYPE_CHECKING: + import collections.abc + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.classes import enums +from test.driver_psycopg_async.pydantic.classes import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetEmbeddedTestPostgresTypeRow(pydantic.BaseModel): + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +class GetAllEmbeddedTestPostgresTypeRow(pydantic.BaseModel): + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes: + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +class TestCopyFromParams(pydantic.BaseModel): + """Model representing TestCopyFromParams. + + Attributes: + id_: int + float_test: float + int_test: int + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class Queries: + """Queries from file queries.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def get_one_test_postgres_type(self, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_inner_test_postgres_type(self, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Args: + table_id: int. + + Returns: + Result of type `models.TestInnerPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + async def get_one_test_timestamp_postgres_type(self, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `datetime.datetime` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + async def get_one_test_bytea_postgres_type(self, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `memoryview` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + def get_many_test_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_iterator_postgres_type(self, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(self._conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + def get_many_test_timestamp_postgres_type(self, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[datetime.datetime]` that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(self._conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + def get_many_test_bytea_postgres_type(self, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[memoryview]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(self._conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + async def get_embedded_test_postgres_type(self, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `GetEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def get_all_embedded_test_postgres_type(self, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `GetAllEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + async def create_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def create_one_test_postgres_inner_type( + self, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, + ) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + table_id: int. + serial_test: int | None. + serial4_test: int | None. + bigserial_test: int | None. + smallserial_test: int | None. + int_test: int | None. + bigint_test: int | None. + smallint_test: int | None. + float_test: float | None. + double_precision_test: float | None. + real_test: float | None. + numeric_test: decimal.Decimal | None. + money_test: str | None. + bool_test: bool | None. + json_test: str | None. + jsonb_test: str | None. + bytea_test: memoryview | None. + date_test: datetime.date | None. + time_test: datetime.time | None. + timetz_test: datetime.time | None. + timestamp_test: datetime.datetime | None. + timestamptz_test: datetime.datetime | None. + interval_test: datetime.timedelta | None. + text_test: str | None. + varchar_test: str | None. + bpchar_test: str | None. + char_test: str | None. + citext_test: str | None. + uuid_test: uuid.UUID | None. + inet_test: str | None. + cidr_test: str | None. + macaddr_test: str | None. + macaddr8_test: str | None. + ltree_test: str | None. + lquery_test: str | None. + ltxtquery_test: str | None. + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + async def delete_one_test_postgres_type(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_test_postgres_inner_type(self, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Args: + table_id: int. + """ + await self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + async def create_result_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + async def update_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + async def create_rows_one_test_postgres_type( + self, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, + ) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + async def update_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def delete_one_rows_test_postgres_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + async def create_rows_table(self) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + async def test_copy_from(self, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Args: + params: collections.abc.Sequence[TestCopyFromParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + async def insert_type_override(self, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Args: + id_: int. + text_test: UserString | None. + """ + await self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + async def get_one_type_override(self, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestTypeOverride` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + def get_many_type_override(self, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestTypeOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(self._conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def get_one_text_type_override(self, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `UserString` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + def get_many_text_type_override(self, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Helper class of type `QueryResults[UserString | None]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(self._conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + async def delete_type_override(self, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Args: + id_: int. + """ + await self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + async def insert_one_test_enum_type(self, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + id_: int. + mood: enums.TestMood. + maybe_mood: enums.TestMood | None. + """ + await self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + async def get_one_test_enum_type(self, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestEnumType` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + async def get_one_test_enum_value(self, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `enums.TestMood` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + def get_many_test_enum_types(self) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Returns: + Helper class of type `QueryResults[models.TestEnumType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(self._conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + async def delete_one_test_enum_type(self, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/pydantic/classes/queries_copy_override.py b/test/driver_psycopg_async/pydantic/classes/queries_copy_override.py new file mode 100644 index 00000000..1a816c13 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/queries_copy_override.py @@ -0,0 +1,118 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "QueriesCopyOverride", +) + +import decimal +import pydantic +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +class CopyOverrideRowsParams(pydantic.BaseModel): + """Model representing CopyOverrideRowsParams. + + Attributes: + id_: int + amount: float + co_l: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +class QueriesCopyOverride: + """Queries from file queries_copy_override.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def copy_override_rows(self, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Args: + params: collections.abc.Sequence[CopyOverrideRowsParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with self._conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + async def count_copy_override_rows(self) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + async def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + await self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/pydantic/classes/queries_enum_override.py b/test/driver_psycopg_async/pydantic/classes/queries_enum_override.py new file mode 100644 index 00000000..25aa13db --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/queries_enum_override.py @@ -0,0 +1,211 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueriesEnumOverride", + "QueryResults", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.classes import enums +from test.driver_psycopg_async.pydantic.classes import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +class QueriesEnumOverride: + """Queries from file queries_enum_override.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def insert_enum_override(self, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + id_: int. + mood_test: str. + """ + await self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + async def get_enum_override_mood(self, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `str` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + def list_enum_override_by_ids(self, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Args: + dollar_1: collections.abc.Sequence[int]. + + Returns: + Helper class of type `QueryResults[models.TestEnumOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(self._conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + async def count_enum_override_by_moods(self, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Args: + dollar_1: collections.abc.Sequence[enums.TestMood]. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/pydantic/classes/queries_field_namings.py b/test/driver_psycopg_async/pydantic/classes/queries_field_namings.py new file mode 100644 index 00000000..8f2a4a94 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/queries_field_namings.py @@ -0,0 +1,144 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "QueriesFieldNamings", +) + +import psycopg +import psycopg.rows +import psycopg.types.string +import pydantic +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.classes import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetJoinedFieldNamingsRow(pydantic.BaseModel): + """Model representing GetJoinedFieldNamingsRow. + + Attributes: + outputs: str + outputs_2: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +class QueriesFieldNamings: + """Queries from file queries_field_namings.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def get_field_naming(self, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestFieldNaming` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + async def get_joined_field_namings(self, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Args: + id_: int. + + Returns: + Result of type `GetJoinedFieldNamingsRow` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + async def set_field_naming_outputs(self, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Args: + id_: int. + outputs: str. + outputs_2: str. + """ + await self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/pydantic/classes/queries_invalid_identifiers.py b/test/driver_psycopg_async/pydantic/classes/queries_invalid_identifiers.py new file mode 100644 index 00000000..d4d449bb --- /dev/null +++ b/test/driver_psycopg_async/pydantic/classes/queries_invalid_identifiers.py @@ -0,0 +1,125 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("QueriesInvalidIdentifiers",) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.classes import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +class QueriesInvalidIdentifiers: + """Queries from file queries_invalid_identifiers.sql.""" + + __slots__ = ("_conn",) + + def __init__(self, conn: ConnectionLike) -> None: + """Initialize the instance using the connection. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + self._conn = conn + + @property + def conn(self) -> ConnectionLike: + """Connection object used to make queries. + + Returns: + Connection object of type `ConnectionLike` used to make queries. + """ + return self._conn + + async def insert_invalid_identifiers(self, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + id_: int. + column_3p_: str | None. + new_notes: str. + """ + await self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + async def get_invalid_identifiers(self, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.TestInvalidIdentifier` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + async def insert_third_party_stat(self, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + id_: int. + total: int. + """ + await self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + async def get_third_party_stat(self, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Args: + id_: int. + + Returns: + Result of type `models.Model3RdPartyStat` fetched from the db. Will be `None` if not found. + """ + row = await (await self._conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/pydantic/functions/__init__.py b/test/driver_psycopg_async/pydantic/functions/__init__.py new file mode 100644 index 00000000..775f83f8 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/__init__.py @@ -0,0 +1,5 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_psycopg_async/pydantic/functions/enums.py b/test/driver_psycopg_async/pydantic/functions/enums.py new file mode 100644 index 00000000..734b78b6 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/enums.py @@ -0,0 +1,25 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing enums.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ("TestMood",) + +import enum +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + +class TestMood(enum.StrEnum): + """Enum representing TestMood.""" + + SAD = "sad" + OK = "ok" + HAPPY = "happy" + VALUE_24H = "24h" + VALUE__HIDDEN = "_hidden" diff --git a/test/driver_psycopg_async/pydantic/functions/models.py b/test/driver_psycopg_async/pydantic/functions/models.py new file mode 100644 index 00000000..e52b3dfa --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/models.py @@ -0,0 +1,284 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +"""Module containing models.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "Model3RdPartyStat", + "TestEnumOverride", + "TestEnumType", + "TestFieldNaming", + "TestInnerPostgresType", + "TestInvalidIdentifier", + "TestPostgresType", + "TestTypeOverride", +) + +from collections import UserString +import datetime +import decimal +import pydantic +import typing +import uuid + +if typing.TYPE_CHECKING: + import collections.abc + +from test.driver_psycopg_async.pydantic.functions import enums + + +class Model3RdPartyStat(pydantic.BaseModel): + """Model representing Model3RdPartyStat. + + Attributes: + id_: int + total: int + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + total: int + + +class TestEnumOverride(pydantic.BaseModel): + """Model representing TestEnumOverride. + + Attributes: + id_: int + mood_test: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + mood_test: str + + +class TestEnumType(pydantic.BaseModel): + """Model representing TestEnumType. + + Attributes: + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + mood: enums.TestMood + maybe_mood: enums.TestMood | None + + +class TestFieldNaming(pydantic.BaseModel): + """Model representing TestFieldNaming. + + Attributes: + id_: int + outputs: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + outputs: str + + +class TestInnerPostgresType(pydantic.BaseModel): + """Model representing TestInnerPostgresType. + + Attributes: + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + table_id: int + serial_test: int | None + serial4_test: int | None + bigserial_test: int | None + smallserial_test: int | None + int_test: int | None + bigint_test: int | None + smallint_test: int | None + float_test: float | None + double_precision_test: float | None + real_test: float | None + numeric_test: decimal.Decimal | None + money_test: str | None + bool_test: bool | None + json_test: str | None + jsonb_test: str | None + bytea_test: memoryview | None + date_test: datetime.date | None + time_test: datetime.time | None + timetz_test: datetime.time | None + timestamp_test: datetime.datetime | None + timestamptz_test: datetime.datetime | None + interval_test: datetime.timedelta | None + text_test: str | None + varchar_test: str | None + bpchar_test: str | None + char_test: str | None + citext_test: str | None + uuid_test: uuid.UUID | None + inet_test: str | None + cidr_test: str | None + macaddr_test: str | None + macaddr8_test: str | None + ltree_test: str | None + lquery_test: str | None + ltxtquery_test: str | None + + +class TestInvalidIdentifier(pydantic.BaseModel): + """Model representing TestInvalidIdentifier. + + Attributes: + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + column_3p_: str | None + new_notes: str + column__pct: str | None + + +class TestPostgresType(pydantic.BaseModel): + """Model representing TestPostgresType. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + + +class TestTypeOverride(pydantic.BaseModel): + """Model representing TestTypeOverride. + + Attributes: + id_: int + text_test: UserString | None + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + text_test: UserString | None diff --git a/test/driver_psycopg_async/pydantic/functions/queries.py b/test/driver_psycopg_async/pydantic/functions/queries.py new file mode 100644 index 00000000..1b72e807 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/queries.py @@ -0,0 +1,2201 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries.sql +"""Module containing queries from file queries.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetAllEmbeddedTestPostgresTypeRow", + "GetEmbeddedTestPostgresTypeRow", + "QueryResults", + "TestCopyFromParams", + "create_one_test_postgres_inner_type", + "create_one_test_postgres_type", + "create_result_one_test_postgres_type", + "create_rows_one_test_postgres_type", + "create_rows_table", + "delete_one_result_test_postgres_type", + "delete_one_rows_test_postgres_type", + "delete_one_test_enum_type", + "delete_one_test_postgres_inner_type", + "delete_one_test_postgres_type", + "delete_type_override", + "get_all_embedded_test_postgres_type", + "get_embedded_test_postgres_type", + "get_many_test_bytea_postgres_type", + "get_many_test_enum_types", + "get_many_test_iterator_postgres_type", + "get_many_test_postgres_type", + "get_many_test_timestamp_postgres_type", + "get_many_text_type_override", + "get_many_type_override", + "get_one_inner_test_postgres_type", + "get_one_test_bytea_postgres_type", + "get_one_test_enum_type", + "get_one_test_enum_value", + "get_one_test_postgres_type", + "get_one_test_timestamp_postgres_type", + "get_one_text_type_override", + "get_one_type_override", + "insert_one_test_enum_type", + "insert_type_override", + "test_copy_from", + "update_result_test_postgres_type", + "update_rows_test_postgres_type", +) + +from collections import UserString +import datetime +import decimal +import operator +import psycopg +import psycopg.rows +import psycopg.types.string +import pydantic +import typing +import uuid + +if typing.TYPE_CHECKING: + import collections.abc + + type QueryResultsArgsType = int | float | str | memoryview | decimal.Decimal | uuid.UUID | datetime.date | datetime.time | datetime.datetime | datetime.timedelta | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.functions import enums +from test.driver_psycopg_async.pydantic.functions import models + + +psycopg.adapters.register_loader("json", psycopg.types.string.TextLoader) +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetEmbeddedTestPostgresTypeRow(pydantic.BaseModel): + """Model representing GetEmbeddedTestPostgresTypeRow. + + Attributes: + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + serial_test: int + serial4_test: int + bigserial_test: int + smallserial_test: int + int_test: int + bigint_test: int + smallint_test: int + float_test: float + double_precision_test: float + real_test: float + numeric_test: decimal.Decimal + money_test: str + bool_test: bool + json_test: str + jsonb_test: str + bytea_test: memoryview + date_test: datetime.date + time_test: datetime.time + timetz_test: datetime.time + timestamp_test: datetime.datetime + timestamptz_test: datetime.datetime + interval_test: datetime.timedelta + text_test: str + varchar_test: str + bpchar_test: str + char_test: str + citext_test: str + uuid_test: uuid.UUID + inet_test: str + cidr_test: str + macaddr_test: str + macaddr8_test: str + ltree_test: str + lquery_test: str + ltxtquery_test: str + test_inner_postgres_type: models.TestInnerPostgresType + + +class GetAllEmbeddedTestPostgresTypeRow(pydantic.BaseModel): + """Model representing GetAllEmbeddedTestPostgresTypeRow. + + Attributes: + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + test_postgres_type: models.TestPostgresType + test_inner_postgres_type: models.TestInnerPostgresType + + +class TestCopyFromParams(pydantic.BaseModel): + """Model representing TestCopyFromParams. + + Attributes: + id_: int + float_test: float + int_test: int + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + float_test: float + int_test: int + + +GET_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestPostgresType :one +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_INNER_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneInnerTestPostgresType :one +SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_inner_postgres_types +WHERE table_id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_ONE_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 1 +""" + +GET_MANY_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ITERATOR_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestIteratorPostgresType :many +SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test +FROM test_postgres_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_MANY_TEST_BYTEA_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = %(p1)s LIMIT 2 +""" + +GET_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: GetAllEmbeddedTestPostgresType :one +SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +CREATE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +DELETE_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_TEST_POSTGRES_INNER_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = %(p1)s +""" + +CREATE_RESULT_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_RESULT_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_ONE_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) +""" + +UPDATE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = %(p1)s +""" + +DELETE_ONE_ROWS_TEST_POSTGRES_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = %(p1)s +""" + +CREATE_ROWS_TABLE: typing.Final[typing.LiteralString] = """-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +) +""" + +TEST_COPY_FROM: typing.Final[typing.LiteralString] = """-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3) +""" + +INSERT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES (%(p1)s ,%(p2)s) +""" + +GET_ONE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTypeOverride :one +SELECT id, text_test FROM test_type_override WHERE id = %(p1)s +""" + +GET_MANY_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTypeOverride :many +SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_ONE_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +GET_MANY_TEXT_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s +""" + +DELETE_TYPE_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = %(p1)s +""" + +INSERT_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumType :one +SELECT id, mood, maybe_mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_ONE_TEST_ENUM_VALUE: typing.Final[typing.LiteralString] = """-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = %(p1)s +""" + +GET_MANY_TEST_ENUM_TYPES: typing.Final[typing.LiteralString] = """-- name: GetManyTestEnumTypes :many +SELECT id, mood, maybe_mood +FROM test_enum_types +ORDER BY id +""" + +DELETE_ONE_TEST_ENUM_TYPE: typing.Final[typing.LiteralString] = """-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = %(p1)s +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def get_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> models.TestPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestPostgresType :one`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_inner_test_postgres_type(conn: ConnectionLike, *, table_id: int) -> models.TestInnerPostgresType | None: + """Fetch one from the db using the SQL query with `name: GetOneInnerTestPostgresType :one`. + + ```sql + SELECT table_id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_inner_postgres_types + WHERE table_id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + table_id: int. + + Returns: + Result of type `models.TestInnerPostgresType` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_INNER_TEST_POSTGRES_TYPE, {"p1": table_id})).fetchone() + if row is None: + return None + return models.TestInnerPostgresType( + table_id=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]) if row[16] is not None else None, + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]) if row[29] is not None else None, + cidr_test=str(row[30]) if row[30] is not None else None, + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + +async def get_one_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> datetime.datetime | None: + """Fetch one from the db using the SQL query with `name: GetOneTestTimestampPostgresType :one`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `datetime.datetime` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return row[0] + + +async def get_one_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> memoryview | None: + """Fetch one from the db using the SQL query with `name: GetOneTestByteaPostgresType :one`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `memoryview` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_BYTEA_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return memoryview(row[0]) + + +def get_many_test_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_iterator_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestPostgresType]: + """Fetch many from the db using the SQL query with `name: GetManyTestIteratorPostgresType :many`. + + ```sql + SELECT id, serial_test, serial4_test, bigserial_test, smallserial_test, int_test, bigint_test, smallint_test, float_test, double_precision_test, real_test, numeric_test, money_test, bool_test, json_test, jsonb_test, bytea_test, date_test, time_test, timetz_test, timestamp_test, timestamptz_test, interval_test, text_test, varchar_test, bpchar_test, char_test, citext_test, uuid_test, inet_test, cidr_test, macaddr_test, macaddr8_test, ltree_test, lquery_test, ltxtquery_test + FROM test_postgres_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestPostgresType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestPostgresType: + return models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ) + + return QueryResults(conn, GET_MANY_TEST_ITERATOR_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +def get_many_test_timestamp_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[datetime.datetime]: + """Fetch many from the db using the SQL query with `name: GetManyTestTimestampPostgresType :many`. + + ```sql + SELECT timestamp_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[datetime.datetime]` that allows both iteration and normal fetching of data from the db. + """ + return QueryResults(conn, GET_MANY_TEST_TIMESTAMP_POSTGRES_TYPE, operator.itemgetter(0), {"p1": id_}) + + +def get_many_test_bytea_postgres_type(conn: ConnectionLike, *, id_: int) -> QueryResults[memoryview]: + """Fetch many from the db using the SQL query with `name: GetManyTestByteaPostgresType :many`. + + ```sql + SELECT bytea_test + FROM test_postgres_types + WHERE id = %(p1)s LIMIT 2 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[memoryview]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> memoryview: + return memoryview(row[0]) + + return QueryResults(conn, GET_MANY_TEST_BYTEA_POSTGRES_TYPE, _decode_hook, {"p1": id_}) + + +async def get_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `GetEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetEmbeddedTestPostgresTypeRow( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def get_all_embedded_test_postgres_type(conn: ConnectionLike, *, id_: int) -> GetAllEmbeddedTestPostgresTypeRow | None: + """Fetch one from the db using the SQL query with `name: GetAllEmbeddedTestPostgresType :one`. + + ```sql + SELECT test_postgres_types.id, test_postgres_types.serial_test, test_postgres_types.serial4_test, test_postgres_types.bigserial_test, test_postgres_types.smallserial_test, test_postgres_types.int_test, test_postgres_types.bigint_test, test_postgres_types.smallint_test, test_postgres_types.float_test, test_postgres_types.double_precision_test, test_postgres_types.real_test, test_postgres_types.numeric_test, test_postgres_types.money_test, test_postgres_types.bool_test, test_postgres_types.json_test, test_postgres_types.jsonb_test, test_postgres_types.bytea_test, test_postgres_types.date_test, test_postgres_types.time_test, test_postgres_types.timetz_test, test_postgres_types.timestamp_test, test_postgres_types.timestamptz_test, test_postgres_types.interval_test, test_postgres_types.text_test, test_postgres_types.varchar_test, test_postgres_types.bpchar_test, test_postgres_types.char_test, test_postgres_types.citext_test, test_postgres_types.uuid_test, test_postgres_types.inet_test, test_postgres_types.cidr_test, test_postgres_types.macaddr_test, test_postgres_types.macaddr8_test, test_postgres_types.ltree_test, test_postgres_types.lquery_test, test_postgres_types.ltxtquery_test, test_inner_postgres_types.table_id, test_inner_postgres_types.serial_test, test_inner_postgres_types.serial4_test, test_inner_postgres_types.bigserial_test, test_inner_postgres_types.smallserial_test, test_inner_postgres_types.int_test, test_inner_postgres_types.bigint_test, test_inner_postgres_types.smallint_test, test_inner_postgres_types.float_test, test_inner_postgres_types.double_precision_test, test_inner_postgres_types.real_test, test_inner_postgres_types.numeric_test, test_inner_postgres_types.money_test, test_inner_postgres_types.bool_test, test_inner_postgres_types.json_test, test_inner_postgres_types.jsonb_test, test_inner_postgres_types.bytea_test, test_inner_postgres_types.date_test, test_inner_postgres_types.time_test, test_inner_postgres_types.timetz_test, test_inner_postgres_types.timestamp_test, test_inner_postgres_types.timestamptz_test, test_inner_postgres_types.interval_test, test_inner_postgres_types.text_test, test_inner_postgres_types.varchar_test, test_inner_postgres_types.bpchar_test, test_inner_postgres_types.char_test, test_inner_postgres_types.citext_test, test_inner_postgres_types.uuid_test, test_inner_postgres_types.inet_test, test_inner_postgres_types.cidr_test, test_inner_postgres_types.macaddr_test, test_inner_postgres_types.macaddr8_test, test_inner_postgres_types.ltree_test, test_inner_postgres_types.lquery_test, test_inner_postgres_types.ltxtquery_test + FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `GetAllEmbeddedTestPostgresTypeRow` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ALL_EMBEDDED_TEST_POSTGRES_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return GetAllEmbeddedTestPostgresTypeRow( + test_postgres_type=models.TestPostgresType( + id_=row[0], + serial_test=row[1], + serial4_test=row[2], + bigserial_test=row[3], + smallserial_test=row[4], + int_test=row[5], + bigint_test=row[6], + smallint_test=row[7], + float_test=row[8], + double_precision_test=row[9], + real_test=row[10], + numeric_test=row[11], + money_test=row[12], + bool_test=row[13], + json_test=row[14], + jsonb_test=row[15], + bytea_test=memoryview(row[16]), + date_test=row[17], + time_test=row[18], + timetz_test=row[19], + timestamp_test=row[20], + timestamptz_test=row[21], + interval_test=row[22], + text_test=row[23], + varchar_test=row[24], + bpchar_test=row[25], + char_test=row[26], + citext_test=row[27], + uuid_test=row[28], + inet_test=str(row[29]), + cidr_test=str(row[30]), + macaddr_test=row[31], + macaddr8_test=row[32], + ltree_test=row[33], + lquery_test=row[34], + ltxtquery_test=row[35], + ), + test_inner_postgres_type=models.TestInnerPostgresType( + table_id=row[36], + serial_test=row[37], + serial4_test=row[38], + bigserial_test=row[39], + smallserial_test=row[40], + int_test=row[41], + bigint_test=row[42], + smallint_test=row[43], + float_test=row[44], + double_precision_test=row[45], + real_test=row[46], + numeric_test=row[47], + money_test=row[48], + bool_test=row[49], + json_test=row[50], + jsonb_test=row[51], + bytea_test=memoryview(row[52]) if row[52] is not None else None, + date_test=row[53], + time_test=row[54], + timetz_test=row[55], + timestamp_test=row[56], + timestamptz_test=row[57], + interval_test=row[58], + text_test=row[59], + varchar_test=row[60], + bpchar_test=row[61], + char_test=row[62], + citext_test=row[63], + uuid_test=row[64], + inet_test=str(row[65]) if row[65] is not None else None, + cidr_test=str(row[66]) if row[66] is not None else None, + macaddr_test=row[67], + macaddr8_test=row[68], + ltree_test=row[69], + lquery_test=row[70], + ltxtquery_test=row[71], + ), + ) + + +async def create_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresType :exec`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def create_one_test_postgres_inner_type( + conn: ConnectionLike, + *, + table_id: int, + serial_test: int | None, + serial4_test: int | None, + bigserial_test: int | None, + smallserial_test: int | None, + int_test: int | None, + bigint_test: int | None, + smallint_test: int | None, + float_test: float | None, + double_precision_test: float | None, + real_test: float | None, + numeric_test: decimal.Decimal | None, + money_test: str | None, + bool_test: bool | None, + json_test: str | None, + jsonb_test: str | None, + bytea_test: memoryview | None, + date_test: datetime.date | None, + time_test: datetime.time | None, + timetz_test: datetime.time | None, + timestamp_test: datetime.datetime | None, + timestamptz_test: datetime.datetime | None, + interval_test: datetime.timedelta | None, + text_test: str | None, + varchar_test: str | None, + bpchar_test: str | None, + char_test: str | None, + citext_test: str | None, + uuid_test: uuid.UUID | None, + inet_test: str | None, + cidr_test: str | None, + macaddr_test: str | None, + macaddr8_test: str | None, + ltree_test: str | None, + lquery_test: str | None, + ltxtquery_test: str | None, +) -> None: + """Execute SQL query with `name: CreateOneTestPostgresInnerType :exec`. + + ```sql + INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + table_id: int. + serial_test: int | None. + serial4_test: int | None. + bigserial_test: int | None. + smallserial_test: int | None. + int_test: int | None. + bigint_test: int | None. + smallint_test: int | None. + float_test: float | None. + double_precision_test: float | None. + real_test: float | None. + numeric_test: decimal.Decimal | None. + money_test: str | None. + bool_test: bool | None. + json_test: str | None. + jsonb_test: str | None. + bytea_test: memoryview | None. + date_test: datetime.date | None. + time_test: datetime.time | None. + timetz_test: datetime.time | None. + timestamp_test: datetime.datetime | None. + timestamptz_test: datetime.datetime | None. + interval_test: datetime.timedelta | None. + text_test: str | None. + varchar_test: str | None. + bpchar_test: str | None. + char_test: str | None. + citext_test: str | None. + uuid_test: uuid.UUID | None. + inet_test: str | None. + cidr_test: str | None. + macaddr_test: str | None. + macaddr8_test: str | None. + ltree_test: str | None. + lquery_test: str | None. + ltxtquery_test: str | None. + """ + sql_params = { + "p1": table_id, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + await conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +async def delete_one_test_postgres_type(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresType :exec`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_test_postgres_inner_type(conn: ConnectionLike, *, table_id: int) -> None: + """Execute SQL query with `name: DeleteOneTestPostgresInnerType :exec`. + + ```sql + DELETE + FROM test_inner_postgres_types + WHERE test_inner_postgres_types.table_id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + table_id: int. + """ + await conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +async def create_result_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: CreateResultOneTestPostgresType :execresult`. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + return await conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +async def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: UpdateResultTestPostgresType :execresult`. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.AsyncCursor[psycopg.rows.TupleRow]: + """Execute and return the result of SQL query with `name: DeleteOneResultTestPostgresType :execresult`. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The result of type `psycopg.AsyncCursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return await conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +async def create_rows_one_test_postgres_type( + conn: ConnectionLike, + *, + id_: int, + serial_test: int, + serial4_test: int, + bigserial_test: int, + smallserial_test: int, + int_test: int, + bigint_test: int, + smallint_test: int, + float_test: float, + double_precision_test: float, + real_test: float, + numeric_test: decimal.Decimal, + money_test: str, + bool_test: bool, + json_test: str, + jsonb_test: str, + bytea_test: memoryview, + date_test: datetime.date, + time_test: datetime.time, + timetz_test: datetime.time, + timestamp_test: datetime.datetime, + timestamptz_test: datetime.datetime, + interval_test: datetime.timedelta, + text_test: str, + varchar_test: str, + bpchar_test: str, + char_test: str, + citext_test: str, + uuid_test: uuid.UUID, + inet_test: str, + cidr_test: str, + macaddr_test: str, + macaddr8_test: str, + ltree_test: str, + lquery_test: str, + ltxtquery_test: str, +) -> int: + """Execute SQL query with `name: CreateRowsOneTestPostgresType :execrows` and return the number of affected rows. + + ```sql + INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) + VALUES (%(p1)s, %(p2)s, %(p3)s, %(p4)s, %(p5)s, %(p6)s, %(p7)s, %(p8)s, + %(p9)s, %(p10)s, %(p11)s, %(p12)s, %(p13)s, %(p14)s, %(p15)s, %(p16)s, + %(p17)s, %(p18)s, %(p19)s, %(p20)s, %(p21)s, %(p22)s, %(p23)s, %(p24)s, + %(p25)s, %(p26)s, %(p27)s, %(p28)s, %(p29)s, %(p30)s, %(p31)s, %(p32)s, + %(p33)s, %(p34)s, %(p35)s, %(p36)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + serial_test: int. + serial4_test: int. + bigserial_test: int. + smallserial_test: int. + int_test: int. + bigint_test: int. + smallint_test: int. + float_test: float. + double_precision_test: float. + real_test: float. + numeric_test: decimal.Decimal. + money_test: str. + bool_test: bool. + json_test: str. + jsonb_test: str. + bytea_test: memoryview. + date_test: datetime.date. + time_test: datetime.time. + timetz_test: datetime.time. + timestamp_test: datetime.datetime. + timestamptz_test: datetime.datetime. + interval_test: datetime.timedelta. + text_test: str. + varchar_test: str. + bpchar_test: str. + char_test: str. + citext_test: str. + uuid_test: uuid.UUID. + inet_test: str. + cidr_test: str. + macaddr_test: str. + macaddr8_test: str. + ltree_test: str. + lquery_test: str. + ltxtquery_test: str. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + sql_params = { + "p1": id_, + "p2": serial_test, + "p3": serial4_test, + "p4": bigserial_test, + "p5": smallserial_test, + "p6": int_test, + "p7": bigint_test, + "p8": smallint_test, + "p9": float_test, + "p10": double_precision_test, + "p11": real_test, + "p12": numeric_test, + "p13": money_test, + "p14": bool_test, + "p15": json_test, + "p16": jsonb_test, + "p17": bytea_test, + "p18": date_test, + "p19": time_test, + "p20": timetz_test, + "p21": timestamp_test, + "p22": timestamptz_test, + "p23": interval_test, + "p24": text_test, + "p25": varchar_test, + "p26": bpchar_test, + "p27": char_test, + "p28": citext_test, + "p29": uuid_test, + "p30": inet_test, + "p31": cidr_test, + "p32": macaddr_test, + "p33": macaddr8_test, + "p34": ltree_test, + "p35": lquery_test, + "p36": ltxtquery_test, + } + cur = await conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +async def update_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: UpdateRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + UPDATE test_postgres_types + SET serial_test = 187 + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def delete_one_rows_test_postgres_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneRowsTestPostgresType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_postgres_types + WHERE test_postgres_types.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +async def create_rows_table(conn: ConnectionLike) -> int: + """Execute SQL query with `name: CreateRowsTable :execrows` and return the number of affected rows. + + ```sql + CREATE TABLE test_create_rows_table + ( + id int PRIMARY KEY NOT NULL, + test int NOT NULL + ) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: TestCopyFrom :copyfrom` and return the number of affected rows. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + params: collections.abc.Sequence[TestCopyFromParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +async def insert_type_override(conn: ConnectionLike, *, id_: int, text_test: UserString | None) -> None: + """Execute SQL query with `name: InsertTypeOverride :exec`. + + ```sql + INSERT INTO test_type_override ( + id, text_test + ) VALUES (%(p1)s ,%(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + text_test: UserString | None. + """ + await conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +async def get_one_type_override(conn: ConnectionLike, *, id_: int) -> models.TestTypeOverride | None: + """Fetch one from the db using the SQL query with `name: GetOneTypeOverride :one`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestTypeOverride` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + +def get_many_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[models.TestTypeOverride]: + """Fetch many from the db using the SQL query with `name: GetManyTypeOverride :many`. + + ```sql + SELECT id, text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[models.TestTypeOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=row[0], text_test=UserString(row[1]) if row[1] is not None else None) + + return QueryResults(conn, GET_MANY_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def get_one_text_type_override(conn: ConnectionLike, *, id_: int) -> UserString | None: + """Fetch one from the db using the SQL query with `name: GetOneTextTypeOverride :one`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `UserString` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEXT_TYPE_OVERRIDE, {"p1": id_})).fetchone() + if row is None: + return None + return UserString(row[0]) if row[0] is not None else None + + +def get_many_text_type_override(conn: ConnectionLike, *, id_: int) -> QueryResults[UserString | None]: + """Fetch many from the db using the SQL query with `name: GetManyTextTypeOverride :many`. + + ```sql + SELECT text_test FROM test_type_override WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Helper class of type `QueryResults[UserString | None]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> UserString | None: + return UserString(row[0]) if row[0] is not None else None + + return QueryResults(conn, GET_MANY_TEXT_TYPE_OVERRIDE, _decode_hook, {"p1": id_}) + + +async def delete_type_override(conn: ConnectionLike, *, id_: int) -> None: + """Execute SQL query with `name: DeleteTypeOverride :exec`. + + ```sql + DELETE + FROM test_type_override + WHERE test_type_override.id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + """ + await conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +async def insert_one_test_enum_type(conn: ConnectionLike, *, id_: int, mood: enums.TestMood, maybe_mood: enums.TestMood | None) -> None: + """Execute SQL query with `name: InsertOneTestEnumType :exec`. + + ```sql + INSERT INTO test_enum_types (id, mood, maybe_mood) + VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + mood: enums.TestMood. + maybe_mood: enums.TestMood | None. + """ + await conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +async def get_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> models.TestEnumType | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumType :one`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestEnumType` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_TYPE, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + +async def get_one_test_enum_value(conn: ConnectionLike, *, id_: int) -> enums.TestMood | None: + """Fetch one from the db using the SQL query with `name: GetOneTestEnumValue :one`. + + ```sql + SELECT mood + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `enums.TestMood` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ONE_TEST_ENUM_VALUE, {"p1": id_})).fetchone() + if row is None: + return None + return enums.TestMood(row[0]) + + +def get_many_test_enum_types(conn: ConnectionLike) -> QueryResults[models.TestEnumType]: + """Fetch many from the db using the SQL query with `name: GetManyTestEnumTypes :many`. + + ```sql + SELECT id, mood, maybe_mood + FROM test_enum_types + ORDER BY id + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + + Returns: + Helper class of type `QueryResults[models.TestEnumType]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumType: + return models.TestEnumType(id_=row[0], mood=enums.TestMood(row[1]), maybe_mood=enums.TestMood(row[2]) if row[2] is not None else None) + + return QueryResults(conn, GET_MANY_TEST_ENUM_TYPES, _decode_hook) + + +async def delete_one_test_enum_type(conn: ConnectionLike, *, id_: int) -> int: + """Execute SQL query with `name: DeleteOneTestEnumType :execrows` and return the number of affected rows. + + ```sql + DELETE + FROM test_enum_types + WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + The number (`int`) of affected rows. This will be -1 for queries like `CREATE TABLE`. + """ + cur = await conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_async/pydantic/functions/queries_copy_override.py b/test/driver_psycopg_async/pydantic/functions/queries_copy_override.py new file mode 100644 index 00000000..3e80740a --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/queries_copy_override.py @@ -0,0 +1,108 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_copy_override.sql +"""Module containing queries from file queries_copy_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "CopyOverrideRowsParams", + "copy_override_rows", + "count_copy_override_rows", + "delete_copy_override_rows", +) + +import decimal +import pydantic +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + + +class CopyOverrideRowsParams(pydantic.BaseModel): + """Model representing CopyOverrideRowsParams. + + Attributes: + id_: int + amount: float + co_l: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + id_: int + amount: float + co_l: str + + +COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3) +""" + +COUNT_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override +""" + +DELETE_COPY_OVERRIDE_ROWS: typing.Final[typing.LiteralString] = """-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override +""" + + +async def copy_override_rows(conn: ConnectionLike, *, params: collections.abc.Sequence[CopyOverrideRowsParams]) -> int: + """Execute COPY FROM query to insert rows into a table with `name: CopyOverrideRows :copyfrom` and return the number of affected rows. + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + params: collections.abc.Sequence[CopyOverrideRowsParams]. + A list of params for rows that should be inserted. + + Returns: + The number (`int`) of affected rows. + """ + async with conn.cursor() as cur: + async with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + await copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +async def count_copy_override_rows(conn: ConnectionLike) -> int | None: + """Fetch one from the db using the SQL query with `name: CountCopyOverrideRows :one`. + + ```sql + SELECT count(*) FROM test_copy_override + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(COUNT_COPY_OVERRIDE_ROWS)).fetchone() + if row is None: + return None + return row[0] + + +async def delete_copy_override_rows(conn: ConnectionLike) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + """ + await conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_async/pydantic/functions/queries_enum_override.py b/test/driver_psycopg_async/pydantic/functions/queries_enum_override.py new file mode 100644 index 00000000..22fe68a2 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/queries_enum_override.py @@ -0,0 +1,202 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_enum_override.sql +"""Module containing queries from file queries_enum_override.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "QueryResults", + "count_enum_override_by_moods", + "get_enum_override_mood", + "insert_enum_override", + "list_enum_override_by_ids", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.functions import enums +from test.driver_psycopg_async.pydantic.functions import models + + +INSERT_ENUM_OVERRIDE: typing.Final[typing.LiteralString] = """-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) +""" + +GET_ENUM_OVERRIDE_MOOD: typing.Final[typing.LiteralString] = """-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = %(p1)s +""" + +LIST_ENUM_OVERRIDE_BY_IDS: typing.Final[typing.LiteralString] = """-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) +""" + +COUNT_ENUM_OVERRIDE_BY_MOODS: typing.Final[typing.LiteralString] = """-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) +""" + + +class QueryResults[T]: + """Helper class that allows both iteration and normal fetching of data from the db.""" + + __slots__ = ("_conn", "_cursor", "_decode_hook", "_iterator", "_params", "_sql") + + def __init__( + self, + conn: ConnectionLike, + sql: typing.LiteralString, + decode_hook: collections.abc.Callable[[psycopg.rows.TupleRow], T], + params: dict[str, QueryResultsArgsType] | None = None, + ) -> None: + """Initialize the QueryResults instance. + + Args: + conn: + The connection object of type `ConnectionLike` used to execute queries. + sql: + The SQL statement that will be executed when fetching/iterating. + decode_hook: + A callback that turns an `psycopg.rows.TupleRow` object into `T` that will be returned. + params: + Named arguments that should be sent when executing the sql query. + """ + self._conn = conn + self._sql: typing.LiteralString = sql + self._decode_hook = decode_hook + self._params = params + self._cursor: psycopg.AsyncCursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.AsyncIterator[psycopg.rows.TupleRow] | None = None + + def __aiter__(self) -> QueryResults[T]: + """Initialize iteration support for `async for`. + + Returns: + Self as an asynchronous iterator. + """ + return self + + def __await__( + self, + ) -> collections.abc.Generator[None, None, collections.abc.Sequence[T]]: + """Allow `await` on the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + + async def _wrapper() -> collections.abc.Sequence[T]: + result = await (await self._conn.execute(self._sql, self._params)).fetchall() + return [self._decode_hook(row) for row in result] + + return _wrapper().__await__() + + async def __anext__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopAsyncIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = await self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__aiter__() + try: + record = await self._iterator.__anext__() + except StopAsyncIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +async def insert_enum_override(conn: ConnectionLike, *, id_: int, mood_test: str) -> None: + """Execute SQL query with `name: InsertEnumOverride :exec`. + + ```sql + INSERT INTO test_enum_override (id, mood_test) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + mood_test: str. + """ + await conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +async def get_enum_override_mood(conn: ConnectionLike, *, id_: int) -> str | None: + """Fetch one from the db using the SQL query with `name: GetEnumOverrideMood :one`. + + ```sql + SELECT mood_test FROM test_enum_override WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `str` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_ENUM_OVERRIDE_MOOD, {"p1": id_})).fetchone() + if row is None: + return None + return str(row[0]) + + +def list_enum_override_by_ids(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[int]) -> QueryResults[models.TestEnumOverride]: + """Fetch many from the db using the SQL query with `name: ListEnumOverrideByIds :many`. + + ```sql + SELECT id, mood_test FROM test_enum_override WHERE id = ANY(%(p1)s::int[]) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + dollar_1: collections.abc.Sequence[int]. + + Returns: + Helper class of type `QueryResults[models.TestEnumOverride]` that allows both iteration and normal fetching of data from the db. + """ + + def _decode_hook(row: psycopg.rows.TupleRow) -> models.TestEnumOverride: + return models.TestEnumOverride(id_=row[0], mood_test=str(row[1])) + + return QueryResults(conn, LIST_ENUM_OVERRIDE_BY_IDS, _decode_hook, {"p1": list(dollar_1)}) + + +async def count_enum_override_by_moods(conn: ConnectionLike, *, dollar_1: collections.abc.Sequence[enums.TestMood]) -> int | None: + """Fetch one from the db using the SQL query with `name: CountEnumOverrideByMoods :one`. + + ```sql + SELECT count(*) FROM test_enum_override WHERE mood_test = ANY(%(p1)s::test_mood[]) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + dollar_1: collections.abc.Sequence[enums.TestMood]. + + Returns: + Result of type `int` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(COUNT_ENUM_OVERRIDE_BY_MOODS, {"p1": list(dollar_1)})).fetchone() + if row is None: + return None + return row[0] diff --git a/test/driver_psycopg_async/pydantic/functions/queries_field_namings.py b/test/driver_psycopg_async/pydantic/functions/queries_field_namings.py new file mode 100644 index 00000000..c156aed8 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/queries_field_namings.py @@ -0,0 +1,131 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_field_namings.sql +"""Module containing queries from file queries_field_namings.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "GetJoinedFieldNamingsRow", + "get_field_naming", + "get_joined_field_namings", + "set_field_naming_outputs", +) + +import psycopg +import psycopg.rows +import psycopg.types.string +import pydantic +import typing + +if typing.TYPE_CHECKING: + import collections.abc + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.functions import models + + +psycopg.adapters.register_loader("jsonb", psycopg.types.string.TextLoader) + + +class GetJoinedFieldNamingsRow(pydantic.BaseModel): + """Model representing GetJoinedFieldNamingsRow. + + Attributes: + outputs: str + outputs_2: str + """ + + model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) + + outputs: str + outputs_2: str + + +GET_FIELD_NAMING: typing.Final[typing.LiteralString] = """-- name: GetFieldNaming :one +SELECT id, outputs +FROM test_field_namings +WHERE id = %(p1)s LIMIT 1 +""" + +GET_JOINED_FIELD_NAMINGS: typing.Final[typing.LiteralString] = """-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = %(p1)s LIMIT 1 +""" + +SET_FIELD_NAMING_OUTPUTS: typing.Final[typing.LiteralString] = """-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = %(p2)s +WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb +""" + + +async def get_field_naming(conn: ConnectionLike, *, id_: int) -> models.TestFieldNaming | None: + """Fetch one from the db using the SQL query with `name: GetFieldNaming :one`. + + ```sql + SELECT id, outputs + FROM test_field_namings + WHERE id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestFieldNaming` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_FIELD_NAMING, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +async def get_joined_field_namings(conn: ConnectionLike, *, id_: int) -> GetJoinedFieldNamingsRow | None: + """Fetch one from the db using the SQL query with `name: GetJoinedFieldNamings :one`. + + ```sql + SELECT a.outputs, b.outputs + FROM test_field_namings a + JOIN test_field_namings b ON a.id = b.id + WHERE a.id = %(p1)s LIMIT 1 + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `GetJoinedFieldNamingsRow` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_})).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +async def set_field_naming_outputs(conn: ConnectionLike, *, id_: int, outputs: str, outputs_2: str) -> None: + """Execute SQL query with `name: SetFieldNamingOutputs :exec`. + + ```sql + UPDATE test_field_namings + SET outputs = %(p2)s + WHERE id = %(p1)s AND outputs <> %(p3)s::jsonb + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + outputs: str. + outputs_2: str. + """ + await conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_async/pydantic/functions/queries_invalid_identifiers.py b/test/driver_psycopg_async/pydantic/functions/queries_invalid_identifiers.py new file mode 100644 index 00000000..39475ebd --- /dev/null +++ b/test/driver_psycopg_async/pydantic/functions/queries_invalid_identifiers.py @@ -0,0 +1,118 @@ +# Code generated by sqlc. DO NOT EDIT. +# versions: +# sqlc v1.31.1 +# sqlc-gen-better-python v0.6.0 +# source file: queries_invalid_identifiers.sql +"""Module containing queries from file queries_invalid_identifiers.sql.""" + +from __future__ import annotations + +__all__: collections.abc.Sequence[str] = ( + "get_invalid_identifiers", + "get_third_party_stat", + "insert_invalid_identifiers", + "insert_third_party_stat", +) + +import typing + +if typing.TYPE_CHECKING: + import collections.abc + import psycopg + import psycopg.rows + + type ConnectionLike = psycopg.AsyncConnection[psycopg.rows.TupleRow] + +from test.driver_psycopg_async.pydantic.functions import models + + +INSERT_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) +""" + +GET_INVALID_IDENTIFIERS: typing.Final[typing.LiteralString] = """-- name: GetInvalidIdentifiers :one +SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s +""" + +INSERT_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) +""" + +GET_THIRD_PARTY_STAT: typing.Final[typing.LiteralString] = """-- name: GetThirdPartyStat :one +SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s +""" + + +async def insert_invalid_identifiers(conn: ConnectionLike, *, id_: int, column_3p_: str | None, new_notes: str) -> None: + """Execute SQL query with `name: InsertInvalidIdentifiers :exec`. + + ```sql + INSERT INTO test_invalid_identifiers (id, "3p%%", "new notes") VALUES (%(p1)s, %(p2)s, %(p3)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + column_3p_: str | None. + new_notes: str. + """ + await conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +async def get_invalid_identifiers(conn: ConnectionLike, *, id_: int) -> models.TestInvalidIdentifier | None: + """Fetch one from the db using the SQL query with `name: GetInvalidIdentifiers :one`. + + ```sql + SELECT id, "3p%%", "new notes", "%%pct" FROM test_invalid_identifiers WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.TestInvalidIdentifier` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_INVALID_IDENTIFIERS, {"p1": id_})).fetchone() + if row is None: + return None + return models.TestInvalidIdentifier(id_=row[0], column_3p_=row[1], new_notes=row[2], column__pct=row[3]) + + +async def insert_third_party_stat(conn: ConnectionLike, *, id_: int, total: int) -> None: + """Execute SQL query with `name: InsertThirdPartyStat :exec`. + + ```sql + INSERT INTO "3rd_party_stats" (id, total) VALUES (%(p1)s, %(p2)s) + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + total: int. + """ + await conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +async def get_third_party_stat(conn: ConnectionLike, *, id_: int) -> models.Model3RdPartyStat | None: + """Fetch one from the db using the SQL query with `name: GetThirdPartyStat :one`. + + ```sql + SELECT id, total FROM "3rd_party_stats" WHERE id = %(p1)s + ``` + + Args: + conn: + Connection object of type `ConnectionLike` used to execute the query. + id_: int. + + Returns: + Result of type `models.Model3RdPartyStat` fetched from the db. Will be `None` if not found. + """ + row = await (await conn.execute(GET_THIRD_PARTY_STAT, {"p1": id_})).fetchone() + if row is None: + return None + return models.Model3RdPartyStat(id_=row[0], total=row[1]) diff --git a/test/driver_psycopg_async/pydantic/ruff.toml b/test/driver_psycopg_async/pydantic/ruff.toml new file mode 100644 index 00000000..ded540a0 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/ruff.toml @@ -0,0 +1,9 @@ +extend="../../../ruff.toml" + + +[lint.flake8-type-checking] +runtime-evaluated-base-classes = ["pydantic.BaseModel"] + + +[lint.pydocstyle] +convention = "google" \ No newline at end of file diff --git a/test/driver_psycopg_async/pydantic/test_psycopg_pydantic_classes.py b/test/driver_psycopg_async/pydantic/test_psycopg_pydantic_classes.py new file mode 100644 index 00000000..4fb6deea --- /dev/null +++ b/test/driver_psycopg_async/pydantic/test_psycopg_pydantic_classes.py @@ -0,0 +1,839 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows + +import math + +import pytest +import pytest_asyncio + +from test.driver_psycopg_async.pydantic.classes import enums +from test.driver_psycopg_async.pydantic.classes import models +from test.driver_psycopg_async.pydantic.classes import queries +from test.driver_psycopg_async.pydantic.classes import queries_enum_override + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestPydanticClasses: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_async_conn) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::create") + async def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + await queries_obj.create_one_test_postgres_type( + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::create_inner", depends=["TestPydanticClasses::create"]) + async def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + await queries_obj.create_one_test_postgres_inner_type( + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::create_inner"], name="TestPydanticClasses::get_one") + async def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one"], name="TestPydanticClasses::get_one_none") + async def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one_none"], name="TestPydanticClasses::get_one_inner") + async def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one_inner"], name="TestPydanticClasses::get_one_inner_none") + async def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_one_inner_none"], + name="TestPydanticClasses::get_one_timestamp", + ) + async def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one_timestamp"], name="TestPydanticClasses::get_one_timestamp_none") + async def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_one_timestamp_none"], + name="TestPydanticClasses::get_one_bytea", + ) + async def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one_bytea"], name="TestPydanticClasses::get_one_bytea_none") + async def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one_bytea_none"], name="TestPydanticClasses::get_many") + async def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_many"], name="TestPydanticClasses::get_many_timestamp") + async def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_timestamp_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_many_timestamp"], + name="TestPydanticClasses::get_many_bytea", + ) + async def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = await queries_obj.get_many_test_bytea_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_many_bytea"], name="TestPydanticClasses::get_embedded") + async def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_embedded"], name="TestPydanticClasses::get_embedded_none") + async def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_embedded_none"], + name="TestPydanticClasses::get_all_embedded", + ) + async def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_all_embedded"], name="TestPydanticClasses::get_all_embedded_none") + async def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = await queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_all_embedded_none"], + name="TestPydanticClasses::get_many_iterator", + ) + async def test_get_many_iterator( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + results = queries_obj.get_many_test_iterator_postgres_type(id_=model.id_) + async with queries_obj.conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_many_iterator"], name="TestPydanticClasses::delete") + async def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::delete"], name="TestPydanticClasses::delete_inner") + async def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::create_result") + async def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_result_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::create_result"], name="TestPydanticClasses::update_result") + async def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::update_result"], name="TestPydanticClasses::delete_result") + async def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::create_rows") + async def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.create_rows_one_test_postgres_type( + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::create_rows"], name="TestPydanticClasses::update_rows") + async def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::update_rows"], name="TestPydanticClasses::delete_rows") + async def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = await queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::delete_rows"], name="TestPydanticClasses::copy_from") + async def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries_obj.test_copy_from(params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries_obj.create_rows_table() + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::insert_type_override", + ) + async def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_type_override", + depends=["TestPydanticClasses::insert_type_override"], + ) + async def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_type_override_none", + depends=["TestPydanticClasses::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::get_many_type_override", + depends=["TestPydanticClasses::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_text_type_override", + depends=["TestPydanticClasses::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_text_type_override_none", + depends=["TestPydanticClasses::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::get_many_text_type_override", + depends=["TestPydanticClasses::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = await queries_obj.get_many_text_type_override(id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticClasses::delete_type_override", + depends=["TestPydanticClasses::get_many_text_type_override"], + ) + async def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + await queries_obj.delete_type_override(id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::insert_enum") + async def test_insert_enum(self, queries_obj: queries.Queries) -> None: + await queries_obj.insert_one_test_enum_type(id_=510006, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::get_enum", depends=["TestPydanticClasses::insert_enum"]) + async def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=510006) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::get_enum_value", depends=["TestPydanticClasses::get_enum"]) + async def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=510006) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum"]) + async def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum"]) + async def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = await queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::get_many_enums", depends=["TestPydanticClasses::get_enum_value"]) + async def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = await queries_obj.get_many_test_enum_types() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::get_many_enums"]) + async def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert await queries_obj.delete_one_test_enum_type(id_=510006) == 1 + + @pytest_asyncio.fixture(scope="session", loop_scope="session") + async def queries_enum_override_obj(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_async_conn) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::insert_enum_override") + async def test_insert_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override_obj.insert_enum_override(id_=520006, mood_test="24h") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum_override"]) + async def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=520006) + assert mood is not None + assert isinstance(mood, str) + assert mood == "24h" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum_override"]) + async def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = await queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::list_enum_override", depends=["TestPydanticClasses::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520006]) + assert len(rows) == 1 + assert rows[0].mood_test == "24h" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + results = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520006]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path; going through the conn + # property also covers its generated accessor. + async with queries_enum_override_obj.conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520006: "24h"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticClasses::count_enum_override", depends=["TestPydanticClasses::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + # No HAPPY in the list: other suites may leave happy rows behind and + # would break the exact count. + count = await queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.VALUE_24H, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticClasses::count_enum_override"]) + async def test_cleanup_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520006}) + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = await no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.VALUE_24H]) + assert count is None diff --git a/test/driver_psycopg_async/pydantic/test_psycopg_pydantic_functions.py b/test/driver_psycopg_async/pydantic/test_psycopg_pydantic_functions.py new file mode 100644 index 00000000..b2cc6714 --- /dev/null +++ b/test/driver_psycopg_async/pydantic/test_psycopg_pydantic_functions.py @@ -0,0 +1,905 @@ +# Copyright (c) 2025-present Rayakame + +# 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. +from __future__ import annotations + +import asyncio +import collections.abc +import datetime +import decimal +import random +import typing +import uuid +from collections import UserString + +if typing.TYPE_CHECKING: + import psycopg + import psycopg.rows + +import math + +import pytest + +from test.driver_psycopg_async.pydantic.functions import enums +from test.driver_psycopg_async.pydantic.functions import models +from test.driver_psycopg_async.pydantic.functions import queries +from test.driver_psycopg_async.pydantic.functions import queries_enum_override + + +class _NoRowCursor: + async def fetchone(self) -> None: + await asyncio.sleep(0) + + +class _NoRowConn: + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + async def execute(self, _query: str, _params: object = None) -> _NoRowCursor: + await asyncio.sleep(0) + return _NoRowCursor() + + +@pytest.mark.asyncio(loop_scope="session") +class TestPydanticFunctions: + @pytest.fixture(scope="session") + def override_model(self) -> models.TestTypeOverride: + return models.TestTypeOverride(id_=random.randint(1, 10000000), text_test=UserString("Test")) + + @pytest.fixture(scope="session") + def model(self) -> models.TestPostgresType: + return models.TestPostgresType( + id_=random.randint(1, 1000000), + serial_test=1, + serial4_test=2, + bigserial_test=3, + smallserial_test=4, + int_test=123, + bigint_test=123_456_789_012_345, + smallint_test=12, + float_test=math.pi, + double_precision_test=math.e, + real_test=3.25, + numeric_test=decimal.Decimal("12345.6789"), + money_test="$99.99", + bool_test=True, + json_test='{"foo": "bar"}', + jsonb_test='{"foo": "bar", "active": true}', + bytea_test=memoryview(b"\x00\x01\x02hello"), + date_test=datetime.date(2025, 1, 1), + time_test=datetime.time(14, 30, 0), + timetz_test=datetime.time(14, 30, 0, tzinfo=datetime.UTC), + timestamp_test=datetime.datetime(2025, 1, 1, 14, 30, 0), + timestamptz_test=datetime.datetime(2025, 1, 1, 14, 30, 0, tzinfo=datetime.UTC), + interval_test=datetime.timedelta(days=1, hours=2, minutes=30), + text_test="Lorem ipsum", + varchar_test="Example varchar", + bpchar_test="ABCDEFGHIJ", + char_test="X", + citext_test="CaseInsensitive", + uuid_test=uuid.UUID("12345678-1234-5678-1234-567812345678"), + inet_test="192.168.1.1", + cidr_test="192.168.100.0/24", + macaddr_test="08:00:2b:01:02:03", + macaddr8_test="08:00:2b:ff:fe:01:02:03", + ltree_test="Top.Science.Astronomy", + lquery_test="*.Astronomy.*", + ltxtquery_test="Astro* & Stars", + ) + + @pytest.fixture(scope="session") + def inner_model(self, model: models.TestPostgresType) -> models.TestInnerPostgresType: + return models.TestInnerPostgresType( + table_id=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=None, + bigint_test=None, + smallint_test=None, + float_test=None, + double_precision_test=None, + real_test=None, + numeric_test=None, + money_test=None, + bool_test=None, + json_test=None, + jsonb_test=None, + bytea_test=None, + date_test=None, + time_test=None, + timetz_test=None, + timestamp_test=None, + timestamptz_test=None, + interval_test=None, + text_test=None, + varchar_test=None, + bpchar_test=None, + char_test=None, + citext_test=None, + uuid_test=None, + inet_test=None, + cidr_test=None, + macaddr_test=None, + macaddr8_test=None, + ltree_test=None, + lquery_test=None, + ltxtquery_test=None, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::create") + async def test_create( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.create_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::create2", depends=["TestPydanticFunctions::create"]) + async def test_create_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.create_one_test_postgres_inner_type( + conn=psycopg_async_conn, + table_id=inner_model.table_id, + serial_test=inner_model.serial_test, + serial4_test=inner_model.serial4_test, + bigserial_test=inner_model.bigserial_test, + smallserial_test=inner_model.smallserial_test, + int_test=inner_model.int_test, + bigint_test=inner_model.bigint_test, + smallint_test=inner_model.smallint_test, + float_test=inner_model.float_test, + double_precision_test=inner_model.double_precision_test, + real_test=inner_model.real_test, + numeric_test=inner_model.numeric_test, + money_test=inner_model.money_test, + bool_test=inner_model.bool_test, + json_test=inner_model.json_test, + jsonb_test=inner_model.jsonb_test, + bytea_test=inner_model.bytea_test, + date_test=inner_model.date_test, + time_test=inner_model.time_test, + timetz_test=inner_model.timetz_test, + timestamp_test=inner_model.timestamp_test, + timestamptz_test=inner_model.timestamptz_test, + interval_test=inner_model.interval_test, + text_test=inner_model.text_test, + varchar_test=inner_model.varchar_test, + bpchar_test=inner_model.bpchar_test, + char_test=inner_model.char_test, + citext_test=inner_model.citext_test, + uuid_test=inner_model.uuid_test, + inet_test=inner_model.inet_test, + cidr_test=inner_model.cidr_test, + macaddr_test=inner_model.macaddr_test, + macaddr8_test=inner_model.macaddr8_test, + ltree_test=inner_model.ltree_test, + lquery_test=inner_model.lquery_test, + ltxtquery_test=inner_model.ltxtquery_test, + ) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::create2"], name="TestPydanticFunctions::get_one") + async def test_get_one( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one"], name="TestPydanticFunctions::get_one_none") + async def test_get_one_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one_none"], name="TestPydanticFunctions::get_one_inner") + async def test_get_one_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one_inner"], name="TestPydanticFunctions::get_one_inner_none") + async def test_get_one_inner_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_inner_test_postgres_type(conn=psycopg_async_conn, table_id=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_inner_none"], + name="TestPydanticFunctions::get_one_timestamp", + ) + async def test_get_one_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_timestamp"], + name="TestPydanticFunctions::get_one_timestamp_none", + ) + async def test_get_one_timestamp_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_timestamp_none"], + name="TestPydanticFunctions::get_one_bytea", + ) + async def test_get_one_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_bytea"], + name="TestPydanticFunctions::get_one_bytea_none", + ) + async def test_get_one_bytea_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_one_test_bytea_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one_bytea_none"], name="TestPydanticFunctions::get_many") + async def test_get_many( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], models.TestPostgresType) + + first_result = result[0] + assert first_result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_many"], + name="TestPydanticFunctions::get_many_timestamp", + ) + async def test_get_many_timestamp( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_timestamp_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], datetime.datetime) + + assert result[0] == model.timestamp_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_many_timestamp"], + name="TestPydanticFunctions::get_many_bytea", + ) + async def test_get_many_bytea( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.get_many_test_bytea_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, collections.abc.Sequence) + assert isinstance(result[0], memoryview) + + assert result[0] == model.bytea_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_many_bytea"], + name="TestPydanticFunctions::get_embedded", + ) + async def test_get_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.id_ == model.id_ + assert result.serial_test == model.serial_test + assert result.serial4_test == model.serial4_test + assert result.bigserial_test == model.bigserial_test + assert result.smallserial_test == model.smallserial_test + assert result.int_test == model.int_test + assert result.bigint_test == model.bigint_test + assert result.smallint_test == model.smallint_test + assert result.float_test == model.float_test + assert result.double_precision_test == model.double_precision_test + assert result.real_test == model.real_test + assert result.numeric_test == model.numeric_test + assert result.money_test == model.money_test + assert result.bool_test == model.bool_test + assert result.json_test == model.json_test + assert result.jsonb_test == model.jsonb_test + assert result.bytea_test == model.bytea_test + assert result.date_test == model.date_test + assert result.time_test == model.time_test + assert result.timetz_test == model.timetz_test + assert result.timestamp_test == model.timestamp_test + assert result.timestamptz_test == model.timestamptz_test + assert result.interval_test == model.interval_test + assert result.text_test == model.text_test + assert result.varchar_test == model.varchar_test + assert result.bpchar_test == model.bpchar_test + assert result.char_test == model.char_test + assert result.citext_test == model.citext_test + assert result.uuid_test == model.uuid_test + assert result.inet_test == model.inet_test + assert result.cidr_test == model.cidr_test + assert result.macaddr_test == model.macaddr_test + assert result.macaddr8_test == model.macaddr8_test + assert result.ltree_test == model.ltree_test + assert result.lquery_test == model.lquery_test + assert result.ltxtquery_test == model.ltxtquery_test + + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_embedded"], + name="TestPydanticFunctions::get_embedded_none", + ) + async def test_get_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_embedded_none"], + name="TestPydanticFunctions::get_all_embedded", + ) + async def test_get_all_embedded( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, queries.GetAllEmbeddedTestPostgresTypeRow) + assert isinstance(result.test_postgres_type, models.TestPostgresType) + assert isinstance(result.test_inner_postgres_type, models.TestInnerPostgresType) + + assert result.test_postgres_type == model + assert result.test_inner_postgres_type == inner_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_all_embedded"], + name="TestPydanticFunctions::get_all_embedded_none", + ) + async def test_get_all_embedded_none( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.get_all_embedded_test_postgres_type(conn=psycopg_async_conn, id_=0) + + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_all_embedded_none"], + name="TestPydanticFunctions::get_many_iterator", + ) + async def test_get_many_iterator( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_async_conn, id_=model.id_) + async with psycopg_async_conn.transaction(): + async for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_many_iterator"], + name="TestPydanticFunctions::delete", + ) + async def test_delete( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + await queries.delete_one_test_postgres_type(conn=psycopg_async_conn, id_=model.id_) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::delete"], name="TestPydanticFunctions::delete_inner") + async def test_delete_inner( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + await queries.delete_one_test_postgres_inner_type(conn=psycopg_async_conn, table_id=inner_model.table_id) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::create_result") + async def test_create_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_result_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result.statusmessage == "INSERT 0 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::create_result"], + name="TestPydanticFunctions::update_result", + ) + async def test_update_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + depends=["TestPydanticFunctions::update_result"], + name="TestPydanticFunctions::delete_result", + ) + async def test_delete_result( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_result_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::create_rows") + async def test_create_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.create_rows_one_test_postgres_type( + conn=psycopg_async_conn, + id_=model.id_ + 1, + serial_test=model.serial_test, + serial4_test=model.serial4_test, + bigserial_test=model.bigserial_test, + smallserial_test=model.smallserial_test, + int_test=model.int_test, + bigint_test=model.bigint_test, + smallint_test=model.smallint_test, + float_test=model.float_test, + double_precision_test=model.double_precision_test, + real_test=model.real_test, + numeric_test=model.numeric_test, + money_test=model.money_test, + bool_test=model.bool_test, + json_test=model.json_test, + jsonb_test=model.jsonb_test, + bytea_test=model.bytea_test, + date_test=model.date_test, + time_test=model.time_test, + timetz_test=model.timetz_test, + timestamp_test=model.timestamp_test, + timestamptz_test=model.timestamptz_test, + interval_test=model.interval_test, + text_test=model.text_test, + varchar_test=model.varchar_test, + bpchar_test=model.bpchar_test, + char_test=model.char_test, + citext_test=model.citext_test, + uuid_test=model.uuid_test, + inet_test=model.inet_test, + cidr_test=model.cidr_test, + macaddr_test=model.macaddr_test, + macaddr8_test=model.macaddr8_test, + ltree_test=model.ltree_test, + lquery_test=model.lquery_test, + ltxtquery_test=model.ltxtquery_test, + ) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::create_rows"], name="TestPydanticFunctions::update_rows") + async def test_update_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.update_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::update_rows"], name="TestPydanticFunctions::delete_rows") + async def test_delete_rows( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = await queries.delete_one_rows_test_postgres_type(conn=psycopg_async_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::delete_rows"], name="TestPydanticFunctions::copy_from") + async def test_copy_from( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + num = 3 + rows: list[queries.TestCopyFromParams] = [ + queries.TestCopyFromParams( + id_=i, + int_test=model.int_test, + float_test=model.float_test, + ) + for i in range(num) + ] + + result = await queries.test_copy_from(conn=psycopg_async_conn, params=rows) + assert result == num + await psycopg_async_conn.execute("""DELETE FROM test_copy_from;""") + + @pytest.mark.asyncio(loop_scope="session") + async def test_create_table( + self, + psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], + ) -> None: + result = await queries.create_rows_table(conn=psycopg_async_conn) + + assert result == -1 + + await psycopg_async_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::insert_type_override", + ) + async def test_insert_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.insert_type_override(conn=psycopg_async_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_type_override", + depends=["TestPydanticFunctions::insert_type_override"], + ) + async def test_get_one_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_type_override_none", + depends=["TestPydanticFunctions::get_one_type_override"], + ) + async def test_get_one_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::get_many_type_override", + depends=["TestPydanticFunctions::get_one_type_override_none"], + ) + async def test_get_many_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_text_type_override", + depends=["TestPydanticFunctions::get_many_type_override"], + ) + async def test_get_one_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_text_type_override_none", + depends=["TestPydanticFunctions::get_one_text_type_override"], + ) + async def test_get_one_text_type_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_one_text_type_override(conn=psycopg_async_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::get_many_text_type_override", + depends=["TestPydanticFunctions::get_one_text_type_override_none"], + ) + async def test_get_many_text_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = await queries.get_many_text_type_override(conn=psycopg_async_conn, id_=override_model.id_) + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency( + name="TestPydanticFunctions::delete_type_override", + depends=["TestPydanticFunctions::get_many_text_type_override"], + ) + async def test_delete_type_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + await queries.delete_type_override(conn=psycopg_async_conn, id_=override_model.id_) + + @pytest.mark.asyncio(loop_scope="session") + async def test_digit_leading_enum_constant_is_member(self) -> None: + # "_24H" or "_HIDDEN" names would be treated as private by enum. + assert enums.TestMood.VALUE_24H.value == "24h" + assert enums.TestMood("24h") is enums.TestMood.VALUE_24H + assert enums.TestMood.VALUE__HIDDEN.value == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::insert_enum") + async def test_insert_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await queries.insert_one_test_enum_type(conn=psycopg_async_conn, id_=510007, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::get_enum", depends=["TestPydanticFunctions::insert_enum"]) + async def test_get_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=510007) + assert result is not None + assert isinstance(result.mood, enums.TestMood) + assert result.mood is enums.TestMood.HAPPY + assert result.maybe_mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::get_enum_value", depends=["TestPydanticFunctions::get_enum"]) + async def test_get_enum_value(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=510007) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum"]) + async def test_get_enum_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_one_test_enum_type(conn=psycopg_async_conn, id_=987654321) + assert result is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum"]) + async def test_get_enum_value_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries.get_one_test_enum_value(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::get_many_enums", depends=["TestPydanticFunctions::get_enum_value"]) + async def test_get_many_enums(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + result = await queries.get_many_test_enum_types(conn=psycopg_async_conn) + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_many_enums"]) + async def test_delete_enum(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + assert await queries.delete_one_test_enum_type(conn=psycopg_async_conn, id_=510007) == 1 + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::insert_enum_override") + async def test_insert_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # The overridden parameter is a plain str; the generated code converts + # it back to enums.TestMood before it reaches the driver. + await queries_enum_override.insert_enum_override(conn=psycopg_async_conn, id_=520007, mood_test="_hidden") + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum_override"]) + async def test_get_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=520007) + assert mood is not None + assert isinstance(mood, str) + assert mood == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum_override"]) + async def test_get_enum_override_none(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + mood = await queries_enum_override.get_enum_override_mood(conn=psycopg_async_conn, id_=987654321) + assert mood is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::list_enum_override", depends=["TestPydanticFunctions::insert_enum_override"]) + async def test_list_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = await queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[520007]) + assert len(rows) == 1 + assert rows[0].mood_test == "_hidden" + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum_override"]) + async def test_iterate_enum_override_by_ids(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_async_conn, dollar_1=[520007]) + seen: dict[int, str] = {} + # Exercise the cursor-based async-for path. + async with psycopg_async_conn.transaction(): + async for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520007: "_hidden"} + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(name="TestPydanticFunctions::count_enum_override", depends=["TestPydanticFunctions::insert_enum_override"]) + async def test_count_enum_override_by_moods(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + # No HAPPY in the list: other suites may leave happy rows behind and + # would break the exact count. + count = await queries_enum_override.count_enum_override_by_moods(conn=psycopg_async_conn, dollar_1=[enums.TestMood.VALUE__HIDDEN, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.asyncio(loop_scope="session") + async def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.AsyncConnection[psycopg.rows.TupleRow]", _NoRowConn()) + count = await queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.VALUE__HIDDEN]) + assert count is None + + @pytest.mark.asyncio(loop_scope="session") + @pytest.mark.dependency(depends=["TestPydanticFunctions::count_enum_override"]) + async def test_cleanup_enum_override(self, psycopg_async_conn: psycopg.AsyncConnection[psycopg.rows.TupleRow]) -> None: + await psycopg_async_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520007}) diff --git a/test/driver_psycopg_async/queries.sql b/test/driver_psycopg_async/queries.sql new file mode 100644 index 00000000..2c3ea10a --- /dev/null +++ b/test/driver_psycopg_async/queries.sql @@ -0,0 +1,314 @@ +-- name: GetOneTestPostgresType :one +SELECT * +FROM test_postgres_types +WHERE id = $1 LIMIT 1; + +-- name: GetOneInnerTestPostgresType :one +SELECT * +FROM test_inner_postgres_types +WHERE table_id = $1 LIMIT 1; + +-- name: GetOneTestTimestampPostgresType :one +SELECT timestamp_test +FROM test_postgres_types +WHERE id = $1 LIMIT 1; + +-- name: GetOneTestByteaPostgresType :one +SELECT bytea_test +FROM test_postgres_types +WHERE id = $1 LIMIT 1; + +-- name: GetManyTestPostgresType :many +SELECT * +FROM test_postgres_types +WHERE id = $1; + +-- name: GetManyTestIteratorPostgresType :many +SELECT * +FROM test_postgres_types +WHERE id = $1; + +-- name: GetManyTestTimestampPostgresType :many +SELECT timestamp_test +FROM test_postgres_types +WHERE id = $1 LIMIT 2; + +-- name: GetManyTestByteaPostgresType :many +SELECT bytea_test +FROM test_postgres_types +WHERE id = $1 LIMIT 2; + +-- name: GetEmbeddedTestPostgresType :one +SELECT test_postgres_types.*, sqlc.embed(test_inner_postgres_types) +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = $1; + +-- name: GetAllEmbeddedTestPostgresType :one +SELECT sqlc.embed(test_postgres_types), sqlc.embed(test_inner_postgres_types) +FROM test_postgres_types + JOIN test_inner_postgres_types ON test_inner_postgres_types.table_id = test_postgres_types.id +WHERE test_postgres_types.id = $1; + +-- name: CreateOneTestPostgresType :exec +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, + $9, $10, $11, $12, $13, $14, $15, $16, + $17, $18, $19, $20, $21, $22, $23, $24, + $25, $26, $27, $28, $29, $30, $31, $32, + $33, $34, $35, $36); + +-- name: CreateOneTestPostgresInnerType :exec +INSERT INTO test_inner_postgres_types (table_id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, + $9, $10, $11, $12, $13, $14, $15, $16, + $17, $18, $19, $20, $21, $22, $23, $24, + $25, $26, $27, $28, $29, $30, $31, $32, + $33, $34, $35, $36); + +-- name: DeleteOneTestPostgresType :exec +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = $1; + + +-- name: DeleteOneTestPostgresInnerType :exec +DELETE +FROM test_inner_postgres_types +WHERE test_inner_postgres_types.table_id = $1; + +-- name: CreateResultOneTestPostgresType :execresult +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, + $9, $10, $11, $12, $13, $14, $15, $16, + $17, $18, $19, $20, $21, $22, $23, $24, + $25, $26, $27, $28, $29, $30, $31, $32, + $33, $34, $35, $36); + +-- name: UpdateResultTestPostgresType :execresult +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = $1; + +-- name: DeleteOneResultTestPostgresType :execresult +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = $1; + +-- name: CreateRowsOneTestPostgresType :execrows +INSERT INTO test_postgres_types (id, + serial_test, + serial4_test, + bigserial_test, + smallserial_test, + int_test, + bigint_test, + smallint_test, + float_test, + double_precision_test, + real_test, + numeric_test, + money_test, + bool_test, + json_test, + jsonb_test, + bytea_test, + date_test, + time_test, + timetz_test, + timestamp_test, + timestamptz_test, + interval_test, + text_test, + varchar_test, + bpchar_test, + char_test, + citext_test, + uuid_test, + inet_test, + cidr_test, + macaddr_test, + macaddr8_test, + ltree_test, + lquery_test, + ltxtquery_test) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, + $9, $10, $11, $12, $13, $14, $15, $16, + $17, $18, $19, $20, $21, $22, $23, $24, + $25, $26, $27, $28, $29, $30, $31, $32, + $33, $34, $35, $36); + +-- name: UpdateRowsTestPostgresType :execrows +UPDATE test_postgres_types +SET serial_test = 187 +WHERE test_postgres_types.id = $1; + +-- name: DeleteOneRowsTestPostgresType :execrows +DELETE +FROM test_postgres_types +WHERE test_postgres_types.id = $1; + +-- name: CreateRowsTable :execrows +CREATE TABLE test_create_rows_table +( + id int PRIMARY KEY NOT NULL, + test int NOT NULL +); + + + +-- name: TestCopyFrom :copyfrom +INSERT INTO test_copy_from (id, + float_test, int_test) +VALUES ($1, $2, $3); + +-- name: InsertTypeOverride :exec +INSERT INTO test_type_override ( + id, text_test +) VALUES ($1 ,$2); + +-- name: GetOneTypeOverride :one +SELECT * FROM test_type_override WHERE id = $1; + +-- name: GetManyTypeOverride :many +SELECT * FROM test_type_override WHERE test_type_override.id = $1; + +-- name: GetOneTextTypeOverride :one +SELECT text_test FROM test_type_override WHERE test_type_override.id = $1; + +-- name: GetManyTextTypeOverride :many +SELECT text_test FROM test_type_override WHERE test_type_override.id = $1; + +-- name: DeleteTypeOverride :exec +DELETE +FROM test_type_override +WHERE test_type_override.id = $1; + +-- name: InsertOneTestEnumType :exec +INSERT INTO test_enum_types (id, mood, maybe_mood) +VALUES ($1, $2, $3); + +-- name: GetOneTestEnumType :one +SELECT * +FROM test_enum_types +WHERE id = $1; + +-- name: GetOneTestEnumValue :one +SELECT mood +FROM test_enum_types +WHERE id = $1; + +-- name: GetManyTestEnumTypes :many +SELECT * +FROM test_enum_types +ORDER BY id; + +-- name: DeleteOneTestEnumType :execrows +DELETE +FROM test_enum_types +WHERE id = $1; diff --git a/test/driver_psycopg_async/queries_converters.sql b/test/driver_psycopg_async/queries_converters.sql new file mode 100644 index 00000000..ce98ab69 --- /dev/null +++ b/test/driver_psycopg_async/queries_converters.sql @@ -0,0 +1,20 @@ +-- name: InsertConverted :exec +INSERT INTO test_converters (id, prefs, maybe_prefs, tags) VALUES ($1, $2, $3, $4); + +-- name: GetConverted :one +SELECT * FROM test_converters WHERE id = $1; + +-- name: ListConvertedByTags :many +SELECT id FROM test_converters WHERE tags = $1; + +-- name: DeleteConverted :exec +DELETE FROM test_converters WHERE id = $1; + +-- name: InsertConverterArrayRow :exec +INSERT INTO test_converter_array (id, label) VALUES ($1, $2); + +-- name: GetConverterArrayLabel :one +SELECT label FROM test_converter_array WHERE id = $1; + +-- name: FindConverterArrayByLabels :many +SELECT id FROM test_converter_array WHERE label = ANY($1::converter_label[]); diff --git a/test/driver_psycopg_async/queries_copy_override.sql b/test/driver_psycopg_async/queries_copy_override.sql new file mode 100644 index 00000000..d6ed1ec6 --- /dev/null +++ b/test/driver_psycopg_async/queries_copy_override.sql @@ -0,0 +1,8 @@ +-- name: CopyOverrideRows :copyfrom +INSERT INTO test_copy_override (id, amount, "co""l") VALUES ($1, $2, $3); + +-- name: CountCopyOverrideRows :one +SELECT count(*) FROM test_copy_override; + +-- name: DeleteCopyOverrideRows :exec +DELETE FROM test_copy_override; diff --git a/test/driver_psycopg_async/queries_enum_override.sql b/test/driver_psycopg_async/queries_enum_override.sql new file mode 100644 index 00000000..e91b74c4 --- /dev/null +++ b/test/driver_psycopg_async/queries_enum_override.sql @@ -0,0 +1,11 @@ +-- name: InsertEnumOverride :exec +INSERT INTO test_enum_override (id, mood_test) VALUES ($1, $2); + +-- name: GetEnumOverrideMood :one +SELECT mood_test FROM test_enum_override WHERE id = $1; + +-- name: ListEnumOverrideByIds :many +SELECT id, mood_test FROM test_enum_override WHERE id = ANY($1::int[]); + +-- name: CountEnumOverrideByMoods :one +SELECT count(*) FROM test_enum_override WHERE mood_test = ANY($1::test_mood[]); diff --git a/test/driver_psycopg_async/queries_field_namings.sql b/test/driver_psycopg_async/queries_field_namings.sql new file mode 100644 index 00000000..0bdd93f6 --- /dev/null +++ b/test/driver_psycopg_async/queries_field_namings.sql @@ -0,0 +1,15 @@ +-- name: GetFieldNaming :one +SELECT * +FROM test_field_namings +WHERE id = $1 LIMIT 1; + +-- name: GetJoinedFieldNamings :one +SELECT a.outputs, b.outputs +FROM test_field_namings a +JOIN test_field_namings b ON a.id = b.id +WHERE a.id = $1 LIMIT 1; + +-- name: SetFieldNamingOutputs :exec +UPDATE test_field_namings +SET outputs = $2 +WHERE id = $1 AND outputs <> sqlc.arg(outputs)::jsonb; diff --git a/test/driver_psycopg_async/queries_invalid_identifiers.sql b/test/driver_psycopg_async/queries_invalid_identifiers.sql new file mode 100644 index 00000000..91d8653a --- /dev/null +++ b/test/driver_psycopg_async/queries_invalid_identifiers.sql @@ -0,0 +1,11 @@ +-- name: InsertInvalidIdentifiers :exec +INSERT INTO test_invalid_identifiers (id, "3p%", "new notes") VALUES ($1, $2, $3); + +-- name: GetInvalidIdentifiers :one +SELECT * FROM test_invalid_identifiers WHERE id = $1; + +-- name: InsertThirdPartyStat :exec +INSERT INTO "3rd_party_stats" (id, total) VALUES ($1, $2); + +-- name: GetThirdPartyStat :one +SELECT * FROM "3rd_party_stats" WHERE id = $1; diff --git a/test/driver_psycopg_async/schema.sql b/test/driver_psycopg_async/schema.sql new file mode 100644 index 00000000..33c727a3 --- /dev/null +++ b/test/driver_psycopg_async/schema.sql @@ -0,0 +1,208 @@ +CREATE EXTENSION IF NOT EXISTS citext; -- citext +CREATE EXTENSION IF NOT EXISTS ltree; -- ltree / lquery / ltxtquery + +CREATE TABLE IF NOT EXISTS test_postgres_types +( + /* ------------- Integer family ------------- */ + id int PRIMARY KEY NOT NULL, + serial_test serial NOT NULL, + serial4_test serial4 NOT NULL, + bigserial_test bigserial NOT NULL, + smallserial_test smallserial NOT NULL, + int_test int NOT NULL, + bigint_test bigint NOT NULL, + smallint_test smallint NOT NULL, + + /* ------------- Floating-point ------------- */ + float_test float NOT NULL, + double_precision_test double precision NOT NULL, + real_test real NOT NULL, + + /* ------------- Exact numeric ------------- */ + numeric_test numeric(12, 4) NOT NULL, + money_test money NOT NULL, + + /* ------------- Boolean ------------- */ + bool_test boolean NOT NULL, + + /* ------------- JSON / JSONB ------------- */ + json_test json NOT NULL, + jsonb_test jsonb NOT NULL, + + /* ------------- Binary ------------- */ + bytea_test bytea NOT NULL, + + /* ------------- Date & time ------------- */ + date_test date NOT NULL, + time_test time NOT NULL, + timetz_test timetz NOT NULL, + timestamp_test timestamp NOT NULL, + timestamptz_test timestamptz NOT NULL, + interval_test interval NOT NULL, + + /* ------------- Character / text ------------- */ + text_test text NOT NULL, + varchar_test varchar(255) NOT NULL, + bpchar_test bpchar(10) NOT NULL, + char_test char(1) NOT NULL, + citext_test citext NOT NULL, + + /* ------------- UUID ------------- */ + uuid_test uuid NOT NULL, + + /* ------------- Network types ------------- */ + inet_test inet NOT NULL, + cidr_test cidr NOT NULL, + macaddr_test macaddr NOT NULL, + macaddr8_test macaddr8 NOT NULL, + + /* ------------- LTree family ------------- */ + ltree_test ltree NOT NULL, + lquery_test lquery NOT NULL, + ltxtquery_test ltxtquery NOT NULL +); + +CREATE TABLE IF NOT EXISTS test_inner_postgres_types +( + /* ------------- Integer family ------------- */ + table_id int NOT NULL, + serial_test serial , + serial4_test serial4 , + bigserial_test bigserial , + smallserial_test smallserial , + int_test int , + bigint_test bigint , + smallint_test smallint , + + /* ------------- Floating-point ------------- */ + float_test float , + double_precision_test double precision , + real_test real , + + /* ------------- Exact numeric ------------- */ + numeric_test numeric(12, 4) , + money_test money , + + /* ------------- Boolean ------------- */ + bool_test boolean , + + /* ------------- JSON / JSONB ------------- */ + json_test json , + jsonb_test jsonb , + + /* ------------- Binary ------------- */ + bytea_test bytea , + + /* ------------- Date & time ------------- */ + date_test date , + time_test time , + timetz_test timetz , + timestamp_test timestamp , + timestamptz_test timestamptz , + interval_test interval , + + /* ------------- Character / text ------------- */ + text_test text , + varchar_test varchar(255) , + bpchar_test bpchar(10) , + char_test char(1) , + citext_test citext , + + /* ------------- UUID ------------- */ + uuid_test uuid , + + /* ------------- Network types ------------- */ + inet_test inet , + cidr_test cidr , + macaddr_test macaddr , + macaddr8_test macaddr8 , + + /* ------------- LTree family ------------- */ + ltree_test ltree , + lquery_test lquery , + ltxtquery_test ltxtquery +); + + +CREATE TABLE IF NOT EXISTS test_copy_from +( + id int PRIMARY KEY NOT NULL, + float_test float NOT NULL , + int_test int NOT NULL, + created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now() + ); + +CREATE TABLE IF NOT EXISTS test_type_override +( + id integer PRIMARY KEY NOT NULL, + text_test text +); +DROP TABLE IF EXISTS test_enum_types; +DROP TABLE IF EXISTS test_enum_override; +DROP TYPE IF EXISTS test_mood; +-- '24h' and '_hidden' pin the digit- and underscore-leading constant names. +CREATE TYPE test_mood AS ENUM ('sad', 'ok', 'happy', '24h', '_hidden'); + +CREATE TABLE test_enum_types +( + id int PRIMARY KEY NOT NULL, + mood test_mood NOT NULL, + maybe_mood test_mood +); + +CREATE TABLE test_enum_override +( + id int PRIMARY KEY NOT NULL, + mood_test test_mood NOT NULL +); + +-- :copyfrom into a table with an overridden column: the records must be +-- converted back to the driver type before copy_records_to_table. The +-- quoted "co""l" column pins string escaping in the emitted columns list. +CREATE TABLE IF NOT EXISTS test_copy_override +( + id bigint NOT NULL, + amount numeric NOT NULL, + "co""l" text NOT NULL +); + +-- Plural column name: field names must NOT be singularized (only table +-- names and embed fields are). Ported from PR 164. +CREATE TABLE IF NOT EXISTS test_field_namings +( + id bigint PRIMARY KEY NOT NULL, + outputs jsonb NOT NULL +); + +-- Quoted identifiers that are not valid Python names (issue 160). +CREATE TABLE IF NOT EXISTS test_invalid_identifiers +( + id bigint PRIMARY KEY NOT NULL, + "3p%" text, + "new notes" text NOT NULL, + "%pct" text +); + +-- Digit-leading table name: the class gets a Model prefix (Model3RdPartyStat). +CREATE TABLE IF NOT EXISTS "3rd_party_stats" +( + id bigint PRIMARY KEY NOT NULL, + total bigint NOT NULL +); + +CREATE TABLE IF NOT EXISTS test_converters +( + id integer PRIMARY KEY NOT NULL, + prefs jsonb NOT NULL, + maybe_prefs jsonb, + tags text NOT NULL +); + +DROP TABLE IF EXISTS test_converter_array; +DROP DOMAIN IF EXISTS converter_label; +CREATE DOMAIN converter_label AS text; +CREATE TABLE test_converter_array +( + id integer PRIMARY KEY NOT NULL, + label converter_label NOT NULL +); diff --git a/test/driver_psycopg_async/sqlc-gen-better-python.wasm b/test/driver_psycopg_async/sqlc-gen-better-python.wasm new file mode 100644 index 00000000..131a9b8e Binary files /dev/null and b/test/driver_psycopg_async/sqlc-gen-better-python.wasm differ diff --git a/test/driver_psycopg_async/sqlc.yaml b/test/driver_psycopg_async/sqlc.yaml new file mode 100644 index 00000000..424e60e3 --- /dev/null +++ b/test/driver_psycopg_async/sqlc.yaml @@ -0,0 +1,330 @@ +version: "2" +plugins: + - name: python + wasm: + url: file://sqlc-gen-better-python.wasm + sha256: 237081a0a5dfc42156c4cf1fd9b0d20fe8c4bcbbbcb9f9a18fb31f0151b9505e +sql: + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + engine: postgresql + codegen: + - out: /attrs/classes + plugin: python + options: + package: test.driver_psycopg_async.attrs.classes + sql_driver: psycopg_async + model_type: attrs + emit_classes: true + omit_unused_models: true + emit_init_file: true + docstrings: numpy + speedups: true + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + engine: postgresql + codegen: + - out: /attrs/functions + plugin: python + options: + package: test.driver_psycopg_async.attrs.functions + sql_driver: psycopg_async + model_type: attrs + emit_classes: false + omit_unused_models: true + emit_init_file: true + docstrings: numpy + speedups: true + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + engine: postgresql + codegen: + - out: /dataclass/classes + plugin: python + options: + package: test.driver_psycopg_async.dataclass.classes + sql_driver: psycopg_async + model_type: dataclass + emit_classes: true + omit_unused_models: true + emit_init_file: true + docstrings: google + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + - queries_converters.sql + engine: postgresql + codegen: + - out: /dataclass/functions + plugin: python + options: + package: test.driver_psycopg_async.dataclass.functions + sql_driver: psycopg_async + model_type: dataclass + emit_classes: false + omit_unused_models: true + emit_init_file: true + docstrings: google + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + - column: test_converters.prefs + converter: prefs + - column: test_converters.maybe_prefs + converter: prefs + - column: test_converters.tags + converter: tags + # db_type (not column) so the converter reaches the ANY($1::type[]) + # parameter, which column overrides are not linked to. + - db_type: converter_label + converter: label + converters: + - name: prefs + py_type: + import: test.converters + package: Preferences + type: Preferences + to_db: test.converters.encode_preferences + from_db: test.converters.decode_preferences + - name: tags + py_type: + type: frozenset[str] + to_db: test.converters.encode_tags + from_db: test.converters.decode_tags + - name: label + py_type: + import: pathlib + package: PurePosixPath + type: PurePosixPath + to_db: test.converters.encode_label + from_db: test.converters.decode_label + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + engine: postgresql + codegen: + - out: /msgspec/classes + plugin: python + options: + package: test.driver_psycopg_async.msgspec.classes + sql_driver: psycopg_async + model_type: msgspec + emit_classes: true + omit_unused_models: true + emit_init_file: true + docstrings: pep257 + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + engine: postgresql + codegen: + - out: /msgspec/functions + plugin: python + options: + package: test.driver_psycopg_async.msgspec.functions + sql_driver: psycopg_async + model_type: msgspec + emit_classes: false + omit_unused_models: true + emit_init_file: true + docstrings: pep257 + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + engine: postgresql + codegen: + - out: /pydantic/classes + plugin: python + options: + package: test.driver_psycopg_async.pydantic.classes + sql_driver: psycopg_async + model_type: pydantic + emit_classes: true + omit_unused_models: true + emit_init_file: true + docstrings: google + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + - schema: schema.sql + queries: + - queries.sql + - queries_enum_override.sql + - queries_copy_override.sql + - queries_field_namings.sql + - queries_invalid_identifiers.sql + engine: postgresql + codegen: + - out: /pydantic/functions + plugin: python + options: + package: test.driver_psycopg_async.pydantic.functions + sql_driver: psycopg_async + model_type: pydantic + emit_classes: false + omit_unused_models: true + emit_init_file: true + docstrings: google + overrides: + - column: test_type_override.text_test + py_type: + import: collections + package: UserString + type: UserString + - column: test_enum_override.mood_test + py_type: + type: str + - column: test_copy_override.amount + py_type: + type: float + # omit_typechecking_block coverage: the driver hook and QueryResultsArgsType + # must stay runtime-safe when emitted at module level (PEP 695 aliases are + # lazy). Both modules are import-tested at runtime. + - schema: schema.sql + queries: queries_enum_override.sql + engine: postgresql + codegen: + - out: /omit_tc/classes + plugin: python + options: + package: test.driver_psycopg_async.omit_tc.classes + sql_driver: psycopg_async + model_type: dataclass + emit_classes: true + omit_unused_models: true + emit_init_file: true + omit_typechecking_block: true + docstrings: google + overrides: + - column: test_enum_override.mood_test + py_type: + type: str + - schema: schema.sql + queries: queries_enum_override.sql + engine: postgresql + codegen: + - out: /omit_tc/functions + plugin: python + options: + package: test.driver_psycopg_async.omit_tc.functions + sql_driver: psycopg_async + model_type: dataclass + emit_classes: false + omit_unused_models: true + emit_init_file: true + omit_typechecking_block: true + docstrings: google + overrides: + - column: test_enum_override.mood_test + py_type: + type: str diff --git a/test/driver_sqlite3/attrs/classes/__init__.py b/test/driver_sqlite3/attrs/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/attrs/classes/__init__.py +++ b/test/driver_sqlite3/attrs/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/attrs/classes/models.py b/test/driver_sqlite3/attrs/classes/models.py index ddaad85a..7cdd60a9 100644 --- a/test/driver_sqlite3/attrs/classes/models.py +++ b/test/driver_sqlite3/attrs/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/attrs/classes/queries.py b/test/driver_sqlite3/attrs/classes/queries.py index 74d05674..102b33a3 100644 --- a/test/driver_sqlite3/attrs/classes/queries.py +++ b/test/driver_sqlite3/attrs/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/attrs/classes/queries_case.py b/test/driver_sqlite3/attrs/classes/queries_case.py index 55dabf75..dc5b8afe 100644 --- a/test/driver_sqlite3/attrs/classes/queries_case.py +++ b/test/driver_sqlite3/attrs/classes/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/attrs/classes/queries_override_adapter.py b/test/driver_sqlite3/attrs/classes/queries_override_adapter.py index 345a48cc..57e01fb6 100644 --- a/test/driver_sqlite3/attrs/classes/queries_override_adapter.py +++ b/test/driver_sqlite3/attrs/classes/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/attrs/classes/queries_override_converter.py b/test/driver_sqlite3/attrs/classes/queries_override_converter.py index f5fc855a..04714126 100644 --- a/test/driver_sqlite3/attrs/classes/queries_override_converter.py +++ b/test/driver_sqlite3/attrs/classes/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/attrs/classes/queries_unknown_override.py b/test/driver_sqlite3/attrs/classes/queries_unknown_override.py index a63901af..3676c3ee 100644 --- a/test/driver_sqlite3/attrs/classes/queries_unknown_override.py +++ b/test/driver_sqlite3/attrs/classes/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/attrs/functions/__init__.py b/test/driver_sqlite3/attrs/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/attrs/functions/__init__.py +++ b/test/driver_sqlite3/attrs/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/attrs/functions/models.py b/test/driver_sqlite3/attrs/functions/models.py index 7d6aba78..85fb2161 100644 --- a/test/driver_sqlite3/attrs/functions/models.py +++ b/test/driver_sqlite3/attrs/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/attrs/functions/queries.py b/test/driver_sqlite3/attrs/functions/queries.py index 94c5c061..04289a88 100644 --- a/test/driver_sqlite3/attrs/functions/queries.py +++ b/test/driver_sqlite3/attrs/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/attrs/functions/queries_case.py b/test/driver_sqlite3/attrs/functions/queries_case.py index 32f47e5e..83c32f58 100644 --- a/test/driver_sqlite3/attrs/functions/queries_case.py +++ b/test/driver_sqlite3/attrs/functions/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/attrs/functions/queries_override_adapter.py b/test/driver_sqlite3/attrs/functions/queries_override_adapter.py index 18b412d5..084b392c 100644 --- a/test/driver_sqlite3/attrs/functions/queries_override_adapter.py +++ b/test/driver_sqlite3/attrs/functions/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/attrs/functions/queries_override_converter.py b/test/driver_sqlite3/attrs/functions/queries_override_converter.py index 24100b1c..4f6ce142 100644 --- a/test/driver_sqlite3/attrs/functions/queries_override_converter.py +++ b/test/driver_sqlite3/attrs/functions/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/attrs/functions/queries_unknown_override.py b/test/driver_sqlite3/attrs/functions/queries_unknown_override.py index c0bcb631..b270bf01 100644 --- a/test/driver_sqlite3/attrs/functions/queries_unknown_override.py +++ b/test/driver_sqlite3/attrs/functions/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/dataclass/classes/__init__.py b/test/driver_sqlite3/dataclass/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/dataclass/classes/__init__.py +++ b/test/driver_sqlite3/dataclass/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/dataclass/classes/models.py b/test/driver_sqlite3/dataclass/classes/models.py index a7fea135..605098f0 100644 --- a/test/driver_sqlite3/dataclass/classes/models.py +++ b/test/driver_sqlite3/dataclass/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/dataclass/classes/queries.py b/test/driver_sqlite3/dataclass/classes/queries.py index eeaada7a..1c51cd32 100644 --- a/test/driver_sqlite3/dataclass/classes/queries.py +++ b/test/driver_sqlite3/dataclass/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/dataclass/classes/queries_case.py b/test/driver_sqlite3/dataclass/classes/queries_case.py index 7bcd6950..bac19787 100644 --- a/test/driver_sqlite3/dataclass/classes/queries_case.py +++ b/test/driver_sqlite3/dataclass/classes/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/dataclass/classes/queries_override_adapter.py b/test/driver_sqlite3/dataclass/classes/queries_override_adapter.py index 688fc2d3..1f4d102e 100644 --- a/test/driver_sqlite3/dataclass/classes/queries_override_adapter.py +++ b/test/driver_sqlite3/dataclass/classes/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/dataclass/classes/queries_override_converter.py b/test/driver_sqlite3/dataclass/classes/queries_override_converter.py index 808bc07b..3513c51b 100644 --- a/test/driver_sqlite3/dataclass/classes/queries_override_converter.py +++ b/test/driver_sqlite3/dataclass/classes/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/dataclass/classes/queries_unknown_override.py b/test/driver_sqlite3/dataclass/classes/queries_unknown_override.py index 04571a00..860016ab 100644 --- a/test/driver_sqlite3/dataclass/classes/queries_unknown_override.py +++ b/test/driver_sqlite3/dataclass/classes/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/dataclass/functions/__init__.py b/test/driver_sqlite3/dataclass/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/dataclass/functions/__init__.py +++ b/test/driver_sqlite3/dataclass/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/dataclass/functions/models.py b/test/driver_sqlite3/dataclass/functions/models.py index 104044c9..dd17e426 100644 --- a/test/driver_sqlite3/dataclass/functions/models.py +++ b/test/driver_sqlite3/dataclass/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/dataclass/functions/queries.py b/test/driver_sqlite3/dataclass/functions/queries.py index 83f86574..cff712e1 100644 --- a/test/driver_sqlite3/dataclass/functions/queries.py +++ b/test/driver_sqlite3/dataclass/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/dataclass/functions/queries_any_param.py b/test/driver_sqlite3/dataclass/functions/queries_any_param.py index c1ae3378..e4ce2e1d 100644 --- a/test/driver_sqlite3/dataclass/functions/queries_any_param.py +++ b/test/driver_sqlite3/dataclass/functions/queries_any_param.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_any_param.sql """Module containing queries from file queries_any_param.sql.""" diff --git a/test/driver_sqlite3/dataclass/functions/queries_case.py b/test/driver_sqlite3/dataclass/functions/queries_case.py index 9ca8a862..f9b57895 100644 --- a/test/driver_sqlite3/dataclass/functions/queries_case.py +++ b/test/driver_sqlite3/dataclass/functions/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/dataclass/functions/queries_override_adapter.py b/test/driver_sqlite3/dataclass/functions/queries_override_adapter.py index fdfcea17..c6991a9a 100644 --- a/test/driver_sqlite3/dataclass/functions/queries_override_adapter.py +++ b/test/driver_sqlite3/dataclass/functions/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/dataclass/functions/queries_override_converter.py b/test/driver_sqlite3/dataclass/functions/queries_override_converter.py index b7d0d176..b979fab6 100644 --- a/test/driver_sqlite3/dataclass/functions/queries_override_converter.py +++ b/test/driver_sqlite3/dataclass/functions/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/dataclass/functions/queries_slice.py b/test/driver_sqlite3/dataclass/functions/queries_slice.py index ee84b3c1..dc4956d2 100644 --- a/test/driver_sqlite3/dataclass/functions/queries_slice.py +++ b/test/driver_sqlite3/dataclass/functions/queries_slice.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_slice.sql """Module containing queries from file queries_slice.sql.""" diff --git a/test/driver_sqlite3/dataclass/functions/queries_unknown_override.py b/test/driver_sqlite3/dataclass/functions/queries_unknown_override.py index d93e2965..c9d93218 100644 --- a/test/driver_sqlite3/dataclass/functions/queries_unknown_override.py +++ b/test/driver_sqlite3/dataclass/functions/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/msgspec/classes/__init__.py b/test/driver_sqlite3/msgspec/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/msgspec/classes/__init__.py +++ b/test/driver_sqlite3/msgspec/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/msgspec/classes/models.py b/test/driver_sqlite3/msgspec/classes/models.py index 5a45d7e4..e40fa75c 100644 --- a/test/driver_sqlite3/msgspec/classes/models.py +++ b/test/driver_sqlite3/msgspec/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/msgspec/classes/queries.py b/test/driver_sqlite3/msgspec/classes/queries.py index b17b2798..ab64b4f0 100644 --- a/test/driver_sqlite3/msgspec/classes/queries.py +++ b/test/driver_sqlite3/msgspec/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/msgspec/classes/queries_case.py b/test/driver_sqlite3/msgspec/classes/queries_case.py index bcb41905..298ce698 100644 --- a/test/driver_sqlite3/msgspec/classes/queries_case.py +++ b/test/driver_sqlite3/msgspec/classes/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/msgspec/classes/queries_override_adapter.py b/test/driver_sqlite3/msgspec/classes/queries_override_adapter.py index 5c9bc683..a22ff96f 100644 --- a/test/driver_sqlite3/msgspec/classes/queries_override_adapter.py +++ b/test/driver_sqlite3/msgspec/classes/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/msgspec/classes/queries_override_converter.py b/test/driver_sqlite3/msgspec/classes/queries_override_converter.py index f7c665e6..93755a87 100644 --- a/test/driver_sqlite3/msgspec/classes/queries_override_converter.py +++ b/test/driver_sqlite3/msgspec/classes/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/msgspec/classes/queries_unknown_override.py b/test/driver_sqlite3/msgspec/classes/queries_unknown_override.py index 35a0602a..d0a10565 100644 --- a/test/driver_sqlite3/msgspec/classes/queries_unknown_override.py +++ b/test/driver_sqlite3/msgspec/classes/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/msgspec/functions/__init__.py b/test/driver_sqlite3/msgspec/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/msgspec/functions/__init__.py +++ b/test/driver_sqlite3/msgspec/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/msgspec/functions/models.py b/test/driver_sqlite3/msgspec/functions/models.py index 5a45d7e4..e40fa75c 100644 --- a/test/driver_sqlite3/msgspec/functions/models.py +++ b/test/driver_sqlite3/msgspec/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/msgspec/functions/queries.py b/test/driver_sqlite3/msgspec/functions/queries.py index ea9561a9..fe1896e6 100644 --- a/test/driver_sqlite3/msgspec/functions/queries.py +++ b/test/driver_sqlite3/msgspec/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/msgspec/functions/queries_case.py b/test/driver_sqlite3/msgspec/functions/queries_case.py index aa30be20..338980c3 100644 --- a/test/driver_sqlite3/msgspec/functions/queries_case.py +++ b/test/driver_sqlite3/msgspec/functions/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/msgspec/functions/queries_override_adapter.py b/test/driver_sqlite3/msgspec/functions/queries_override_adapter.py index 0517ca7e..b8663f19 100644 --- a/test/driver_sqlite3/msgspec/functions/queries_override_adapter.py +++ b/test/driver_sqlite3/msgspec/functions/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/msgspec/functions/queries_override_converter.py b/test/driver_sqlite3/msgspec/functions/queries_override_converter.py index 7b709f64..47dc7755 100644 --- a/test/driver_sqlite3/msgspec/functions/queries_override_converter.py +++ b/test/driver_sqlite3/msgspec/functions/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/msgspec/functions/queries_unknown_override.py b/test/driver_sqlite3/msgspec/functions/queries_unknown_override.py index e4456fb5..660e4570 100644 --- a/test/driver_sqlite3/msgspec/functions/queries_unknown_override.py +++ b/test/driver_sqlite3/msgspec/functions/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/pydantic/classes/__init__.py b/test/driver_sqlite3/pydantic/classes/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/pydantic/classes/__init__.py +++ b/test/driver_sqlite3/pydantic/classes/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/pydantic/classes/models.py b/test/driver_sqlite3/pydantic/classes/models.py index 889f05ba..d7d1b7f0 100644 --- a/test/driver_sqlite3/pydantic/classes/models.py +++ b/test/driver_sqlite3/pydantic/classes/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/pydantic/classes/queries.py b/test/driver_sqlite3/pydantic/classes/queries.py index cb16a0ad..a75b4711 100644 --- a/test/driver_sqlite3/pydantic/classes/queries.py +++ b/test/driver_sqlite3/pydantic/classes/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/pydantic/classes/queries_case.py b/test/driver_sqlite3/pydantic/classes/queries_case.py index 0ae7bd0f..37b13ed9 100644 --- a/test/driver_sqlite3/pydantic/classes/queries_case.py +++ b/test/driver_sqlite3/pydantic/classes/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/pydantic/classes/queries_override_adapter.py b/test/driver_sqlite3/pydantic/classes/queries_override_adapter.py index 688fc2d3..1f4d102e 100644 --- a/test/driver_sqlite3/pydantic/classes/queries_override_adapter.py +++ b/test/driver_sqlite3/pydantic/classes/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/pydantic/classes/queries_override_converter.py b/test/driver_sqlite3/pydantic/classes/queries_override_converter.py index 808bc07b..3513c51b 100644 --- a/test/driver_sqlite3/pydantic/classes/queries_override_converter.py +++ b/test/driver_sqlite3/pydantic/classes/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/pydantic/classes/queries_unknown_override.py b/test/driver_sqlite3/pydantic/classes/queries_unknown_override.py index 04571a00..860016ab 100644 --- a/test/driver_sqlite3/pydantic/classes/queries_unknown_override.py +++ b/test/driver_sqlite3/pydantic/classes/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/pydantic/functions/__init__.py b/test/driver_sqlite3/pydantic/functions/__init__.py index afacab93..775f83f8 100644 --- a/test/driver_sqlite3/pydantic/functions/__init__.py +++ b/test/driver_sqlite3/pydantic/functions/__init__.py @@ -1,5 +1,5 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Package containing queries and models automatically generated using sqlc-gen-better-python.""" diff --git a/test/driver_sqlite3/pydantic/functions/models.py b/test/driver_sqlite3/pydantic/functions/models.py index 889f05ba..d7d1b7f0 100644 --- a/test/driver_sqlite3/pydantic/functions/models.py +++ b/test/driver_sqlite3/pydantic/functions/models.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 """Module containing models.""" from __future__ import annotations diff --git a/test/driver_sqlite3/pydantic/functions/queries.py b/test/driver_sqlite3/pydantic/functions/queries.py index e10a3393..f5022fd1 100644 --- a/test/driver_sqlite3/pydantic/functions/queries.py +++ b/test/driver_sqlite3/pydantic/functions/queries.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries.sql """Module containing queries from file queries.sql.""" diff --git a/test/driver_sqlite3/pydantic/functions/queries_case.py b/test/driver_sqlite3/pydantic/functions/queries_case.py index e1d9eb2b..e3953482 100644 --- a/test/driver_sqlite3/pydantic/functions/queries_case.py +++ b/test/driver_sqlite3/pydantic/functions/queries_case.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_case.sql """Module containing queries from file queries_case.sql.""" diff --git a/test/driver_sqlite3/pydantic/functions/queries_override_adapter.py b/test/driver_sqlite3/pydantic/functions/queries_override_adapter.py index fdfcea17..c6991a9a 100644 --- a/test/driver_sqlite3/pydantic/functions/queries_override_adapter.py +++ b/test/driver_sqlite3/pydantic/functions/queries_override_adapter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_adapter.sql """Module containing queries from file queries_override_adapter.sql.""" diff --git a/test/driver_sqlite3/pydantic/functions/queries_override_converter.py b/test/driver_sqlite3/pydantic/functions/queries_override_converter.py index b7d0d176..b979fab6 100644 --- a/test/driver_sqlite3/pydantic/functions/queries_override_converter.py +++ b/test/driver_sqlite3/pydantic/functions/queries_override_converter.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_override_converter.sql """Module containing queries from file queries_override_converter.sql.""" diff --git a/test/driver_sqlite3/pydantic/functions/queries_unknown_override.py b/test/driver_sqlite3/pydantic/functions/queries_unknown_override.py index d93e2965..c9d93218 100644 --- a/test/driver_sqlite3/pydantic/functions/queries_unknown_override.py +++ b/test/driver_sqlite3/pydantic/functions/queries_unknown_override.py @@ -1,7 +1,7 @@ # Code generated by sqlc. DO NOT EDIT. # versions: # sqlc v1.31.1 -# sqlc-gen-better-python v0.5.1 +# sqlc-gen-better-python v0.6.0 # source file: queries_unknown_override.sql """Module containing queries from file queries_unknown_override.sql.""" diff --git a/test/driver_sqlite3/sqlc-gen-better-python.wasm b/test/driver_sqlite3/sqlc-gen-better-python.wasm index 4e0b96b3..131a9b8e 100644 Binary files a/test/driver_sqlite3/sqlc-gen-better-python.wasm and b/test/driver_sqlite3/sqlc-gen-better-python.wasm differ diff --git a/test/driver_sqlite3/sqlc.yaml b/test/driver_sqlite3/sqlc.yaml index 9123dd17..e9215385 100644 --- a/test/driver_sqlite3/sqlc.yaml +++ b/test/driver_sqlite3/sqlc.yaml @@ -3,7 +3,7 @@ plugins: - name: python wasm: url: file://sqlc-gen-better-python.wasm - sha256: 78698bcbf8188223f72f98228792f79a1e93dbaa20a6d41995e6eee962a3eb39 + sha256: 237081a0a5dfc42156c4cf1fd9b0d20fe8c4bcbbbcb9f9a18fb31f0151b9505e sql: - schema: schema.sql queries: diff --git a/uv.lock b/uv.lock index f66425e3..428f0aeb 100644 --- a/uv.lock +++ b/uv.lock @@ -355,6 +355,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] +[[package]] +name = "psycopg" +version = "3.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/db/2f/cb91e5502ec9de1de6f1b76cfbf69531932725361168bb06963620c77e2e/psycopg-3.3.4.tar.gz", hash = "sha256:e21207764952cff81b6b8bdacad9a3939f2793367fdac2987b3aac36a651b5bc", size = 165799, upload-time = "2026-05-01T23:31:55.179Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/e0/7b3dee031daae7743609ce3c746565d4a3ed7c2c186479eb48e34e838c64/psycopg-3.3.4-py3-none-any.whl", hash = "sha256:b6bbc25ccf05c8fad3b061d9db2ef0909a555171b84b07f29458a447253d679a", size = 213001, upload-time = "2026-05-01T23:20:50.816Z" }, +] + +[package.optional-dependencies] +binary = [ + { name = "psycopg-binary", marker = "implementation_name != 'pypy'" }, +] + +[[package]] +name = "psycopg-binary" +version = "3.3.4" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/7d/03818e13ba7f36de93573c93ee3482006d3dfa8b0f8d28df511bad0a1a92/psycopg_binary-3.3.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5ab28a2a7649df3b72e6b674b4c190e448e8e77cf496a65bd846472048de2089", size = 4591122, upload-time = "2026-05-01T23:27:56.162Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b9/11b341edf8d54e2694726b273fe9652b254d989f4f63e3ac6816ad6b55f4/psycopg_binary-3.3.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6402a9d8146cf4b3974ded3fd28a971e83dc6a0333eb7822524a3aa20b546578", size = 4669943, upload-time = "2026-05-01T23:28:04.522Z" }, + { url = "https://files.pythonhosted.org/packages/8b/18/4665bacd65e7865b4372fcd8abb8b9186ada4b0025f8c2ca691b364a556c/psycopg_binary-3.3.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:580ae30a5f95ccd90008ec697d3ed6a4a2047a516407ad904283fa42086936e9", size = 5469697, upload-time = "2026-05-01T23:28:11.337Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b1/b83136c6e510593d9b0c759ba5384337bc4ad82d19fda675adc4b2703c84/psycopg_binary-3.3.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7510c37550f91a187e3660a8cc50d4b760f8c3b8b2f89ebc5698cd2c7f2c85d", size = 5152995, upload-time = "2026-05-01T23:28:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/67/8d/a9821e2a648afe6091989929982a3b0f00b2631a859cb81379728f08fb75/psycopg_binary-3.3.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77df19583501ea288eaf15ac0fe7ad01e6d8091a91d5c41df5c718f307d8e31b", size = 6738180, upload-time = "2026-05-01T23:28:30.654Z" }, + { url = "https://files.pythonhosted.org/packages/7e/58/2e349e8d23905dc2317b80ac65f48fb6f821a4777a4e994a60da91c4850f/psycopg_binary-3.3.4-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:018fbed325936da502feb546642c982dcc4b9ffdea32dfef78dbf3b7f7ad4070", size = 4978828, upload-time = "2026-05-01T23:28:37.277Z" }, + { url = "https://files.pythonhosted.org/packages/45/48/57b00d03b4721878326122a1f1e6b0a90b85bcaec56b5b2f8ea6cfa45235/psycopg_binary-3.3.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:17a21953a9e5ff3a16dab692625a3676e2f101db5e40072f39dbee2250194d68", size = 4509757, upload-time = "2026-05-01T23:28:43.078Z" }, + { url = "https://files.pythonhosted.org/packages/25/37/33b47d8c007df69aec500df5889767c4d313748e8e9e27a2fef8a6dabcee/psycopg_binary-3.3.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:eb05ee1c2b817d27c537333224c9e83c7afb86fe7296ba970990068baf819b16", size = 4190546, upload-time = "2026-05-01T23:28:50.016Z" }, + { url = "https://files.pythonhosted.org/packages/ca/c6/32b0835dbc2122617902b649d76a91c1e75406e76bf3d595b0c3bb5ffad6/psycopg_binary-3.3.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:773d573e11f437ce0bdb95b7c18dc58390494f96d43f8b45b9760436114f7652", size = 3926197, upload-time = "2026-05-01T23:28:55.55Z" }, + { url = "https://files.pythonhosted.org/packages/cd/68/d190ef0c0c5b16ded07831dabc8ddd412f4cdab07ec6e30ed38d9bda0e1f/psycopg_binary-3.3.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:71e55ccbdfae79a2ed9c6369c3008a3025817ff9d7e27b32a2d84e2a4267e66e", size = 4236627, upload-time = "2026-05-01T23:29:05.336Z" }, + { url = "https://files.pythonhosted.org/packages/25/8f/81dcbc2e8454b74d14881275ea45f00791052dac531a9fa8be1730d1685b/psycopg_binary-3.3.4-cp312-cp312-win_amd64.whl", hash = "sha256:494ca54901be8cf9eb7e02c25b731f2317c378efa44f43e8f9bd0e1184ae7be4", size = 3560782, upload-time = "2026-05-01T23:29:11.967Z" }, + { url = "https://files.pythonhosted.org/packages/09/43/13e9c406fbbf354580476e248a16b64802a376873ebe6339e30bb655572d/psycopg_binary-3.3.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fbd1d4ed566895ad2d3bf4ddfd8bae90026930ddf29df3b9d91d32c8c47866a7", size = 4590377, upload-time = "2026-05-01T23:29:18.782Z" }, + { url = "https://files.pythonhosted.org/packages/22/be/2923cd7c3683e7afdecf4f10796a18de02f5c5ddc0969aa2ad0a8cdd3bbd/psycopg_binary-3.3.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:75a9067e236f9b9ae3535b66fe99bddb33d39c0de10112e49b9ab11eee53dc31", size = 4669023, upload-time = "2026-05-01T23:29:25.884Z" }, + { url = "https://files.pythonhosted.org/packages/96/a0/2c913d6fe13d6a8bd13597d36739bf47af063ad9399e402cfecab16f3c1e/psycopg_binary-3.3.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:b56b603ebcea8aa10b46228b8410ba7f13e7c2ee54389d4d9be0927fd8ce2a70", size = 5467423, upload-time = "2026-05-01T23:29:33.416Z" }, + { url = "https://files.pythonhosted.org/packages/e7/38/205d10bc1ad0df4a21c5c51659126bd3ea0ef98fcad1e852f78c249bb9c3/psycopg_binary-3.3.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c677c4ad433cb7150c8cd304a0769ae3bcfbe5ea0676eb53faa7b1443b16d0d3", size = 5151137, upload-time = "2026-05-01T23:29:42.013Z" }, + { url = "https://files.pythonhosted.org/packages/36/fc/f0381ddcd45eff3bb70dbca6823a996048d7f507b2ec3fc92c6fabc0fe87/psycopg_binary-3.3.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:26df2717e59c0473e4465a97dfb1b7afebaa479277870fd5784d1436470db47c", size = 6736671, upload-time = "2026-05-01T23:29:51.626Z" }, + { url = "https://files.pythonhosted.org/packages/95/40/fa545ae152c24327651e5624e4902121e808270be36c10b12e9939be09bc/psycopg_binary-3.3.4-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1dc1f79fd16bb1f3f4421417a514607539f17804d95c7ed617265369d1981cae", size = 4979601, upload-time = "2026-05-01T23:29:56.961Z" }, + { url = "https://files.pythonhosted.org/packages/86/e4/2f8a47ee97f90cd2b933d0463081d35631ff419de2b8c984a5f369857de0/psycopg_binary-3.3.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:136f199a407b5348b9b857c504aff60c77622a28482e7195839ce1b51238c4cc", size = 4510513, upload-time = "2026-05-01T23:30:07.243Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0e/94e842ff4a7f98ed162580ca2e8b8864b28c1e0350f2443f8ee47f821167/psycopg_binary-3.3.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b6f5a29e9c775b9f12a1a717aa7a2c80f9e1db6f27ba44a5b59c80ac61d2ffcf", size = 4187243, upload-time = "2026-05-01T23:30:15.352Z" }, + { url = "https://files.pythonhosted.org/packages/d0/83/fc6c174b672e29b7de996ea77b6cbddf46c891751c3355f6974292baa6b4/psycopg_binary-3.3.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:ee17a2cf4943cde261adfad1bbc5bf38d6b3776d7afff74c7cabcbeaeb08c260", size = 3927347, upload-time = "2026-05-01T23:30:21.186Z" }, + { url = "https://files.pythonhosted.org/packages/e9/65/768364d4a97a15b1a7f47ba52688c1686f22941d8332a8398cefc468e25f/psycopg_binary-3.3.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5c4ab71be17bdca30cb34c34c4e1496e2f5d6f20c199c12bad226070b22ef9bf", size = 4236393, upload-time = "2026-05-01T23:30:26.211Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3b/218efbc9e645becd80cdf651acda05f85cfe546b7a9c0458c7cbc8fe1f74/psycopg_binary-3.3.4-cp313-cp313-win_amd64.whl", hash = "sha256:dbfdb9b6cc79f31104a7b162a2b921b765fcc62af6c00540a167a8de47e4ed38", size = 3564592, upload-time = "2026-05-01T23:30:31.764Z" }, + { url = "https://files.pythonhosted.org/packages/48/a6/828c9185701dab71b234c2a76c38a08b098ebfec5020716b4e93807492b5/psycopg_binary-3.3.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:28b7398fdd19db3232c884fb24550bdfe951221f510e195e233299e4c9b78f97", size = 4607292, upload-time = "2026-05-01T23:30:38.962Z" }, + { url = "https://files.pythonhosted.org/packages/92/58/5b40dbc9d839045c9dae956960e4fb6d20bcabe6c59a2aa34fc3a371913f/psycopg_binary-3.3.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1fbaa292a3c8bb61b45df1ad3da1908ccee7cb889db9425e3557d9e34e2a4829", size = 4687023, upload-time = "2026-05-01T23:30:47.227Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/793f0ac107a9003b48441d0d1f9f616d96e0f37458dd8dc12528ceff55fb/psycopg_binary-3.3.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:94596f9e7633ee3f6440711d43bb70aa31cc0a46a900ab8b4201a366ace5c9e7", size = 5486985, upload-time = "2026-05-01T23:30:55.517Z" }, + { url = "https://files.pythonhosted.org/packages/8f/26/42e8533497e2592334f68ec529cf5f840f7fa4e99575a4bb61aa184dbfbf/psycopg_binary-3.3.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8c0056529e68dbe9184cd4019a1f3d8f3a4ead2f6fc7a5afcf27d3314edd1277", size = 5168745, upload-time = "2026-05-01T23:31:01.904Z" }, + { url = "https://files.pythonhosted.org/packages/15/af/b7151776cc08d5935d45c833ec818a9beb417cf7c08239af1aafbdae78ee/psycopg_binary-3.3.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c09aad7051326e7603c14e50636db9c01f78272dc54b3accff03d46370461e6", size = 6761486, upload-time = "2026-05-01T23:31:14.511Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ed/c92533b9124712d592cbf1cd6c76da933a2e0acea81dfe1fbe7e735f0cff/psycopg_binary-3.3.4-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:514404ed543efd620c85602b747df2a23cf1241b4067199e1a66f2d2757aaa41", size = 4997427, upload-time = "2026-05-01T23:31:20.901Z" }, + { url = "https://files.pythonhosted.org/packages/a2/23/ccadfd0de416aa188356daa199453af24087b042e296088706d190ae0295/psycopg_binary-3.3.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:46893c26858be12cc49ca4226ed6a60b4bfccadd946b3bebb783a60b38788228", size = 4533549, upload-time = "2026-05-01T23:31:26.204Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a0/c8f43cee36386f7bc891ab41a9d31ea07cf9826038e732da79f26b1e5f34/psycopg_binary-3.3.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:df1d567fc430f6df15c9fcf67d87685fc49bdb325adc0db5af1adfb2f44eb5c9", size = 4210256, upload-time = "2026-05-01T23:31:33.884Z" }, + { url = "https://files.pythonhosted.org/packages/4e/2c/c1547871be3790676e8868b38655496422f94f0978dfb66b74bdba2f1676/psycopg_binary-3.3.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:6b9016b1714da4dd5ecaaa75b82098aa5a0b87854ce9b092e21c27c4ae23e014", size = 3946204, upload-time = "2026-05-01T23:31:39.626Z" }, + { url = "https://files.pythonhosted.org/packages/c4/b1/f6670f00fa7ea601584623f6c11602ab92117d83eaff885e0210f6de7418/psycopg_binary-3.3.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:47c656a8a7ba6eb0cff1801a4caaa9c8bdc12d03080e273aff1c8ac39971a77e", size = 4255811, upload-time = "2026-05-01T23:31:44.986Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e6/5fff07a70d1f945ed90ae131c3bd76cab32beff7c58c6db15ad5820b6d1f/psycopg_binary-3.3.4-cp314-cp314-win_amd64.whl", hash = "sha256:c37e024c07308cd06cf3ec51bfd0e7f6157585a4d84d1bce4a7f5f7913719bf8", size = 3666849, upload-time = "2026-05-01T23:31:51.165Z" }, +] + [[package]] name = "pydantic" version = "2.13.4" @@ -577,6 +635,7 @@ dependencies = [ { name = "attrs" }, { name = "ciso8601" }, { name = "msgspec" }, + { name = "psycopg", extra = ["binary"] }, { name = "pydantic" }, ] @@ -625,6 +684,7 @@ requires-dist = [ { name = "attrs", specifier = ">=25.3.0" }, { name = "ciso8601", specifier = ">=2.3.2" }, { name = "msgspec", specifier = ">=0.19.0" }, + { name = "psycopg", extras = ["binary"], specifier = ">=3.2" }, { name = "pydantic", specifier = ">=2.9.0" }, ] @@ -681,6 +741,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, ] +[[package]] +name = "tzdata" +version = "2026.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/ff/5a28bdfd8c3ebec42564ac7d0e54ca3db65044a9314a97f9564fa7a1e926/tzdata-2026.3.tar.gz", hash = "sha256:4a1518b8993086a7982523e071643f3c0e5f213e75b21318e78bcabfff9d1415", size = 198674, upload-time = "2026-07-10T08:50:37.887Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/6d/b53b99a9f2766d095985947a5782f1702cabb129a34f7a802d7197af832f/tzdata-2026.3-py2.py3-none-any.whl", hash = "sha256:dc096730c87af6cab1b171c9d532be840741ff5d459015e7f6947bd7d7e54931", size = 348168, upload-time = "2026-07-10T08:50:36.46Z" }, +] + [[package]] name = "virtualenv" version = "21.7.0"