diff --git a/.changes/unreleased/Added-20260724-120000.yaml b/.changes/unreleased/Added-20260724-120000.yaml new file mode 100644 index 0000000..4f13da5 --- /dev/null +++ b/.changes/unreleased/Added-20260724-120000.yaml @@ -0,0 +1,6 @@ +kind: Added +body: 'Synchronous Psycopg 3 support: the new `sql_driver` value `psycopg_sync` generates plain synchronous code for `psycopg` with the same supported commands (`:execlastid` stays excluded), models, placeholder rewriting, and type contract as `psycopg_async` - including `:copyfrom` via `cursor.copy()` and the raw-text loader keeping returned `json`/`jsonb` columns `str`. `:many` queries return the same `QueryResults` helper, called instead of awaited. Requires `psycopg >= 3.2`.' +time: 2026-07-24T12:00:00.0000000Z +custom: + Author: Rayakame + PR: "222" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 658e063..95c3bd7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -198,6 +198,29 @@ jobs: - name: Run sqlc verify via nox run: | uv run nox -s psycopg_async_check + psycopg-sync: + runs-on: ubuntu-latest + name: "Run psycopg_sync 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.32" + 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_sync_check aiosqlite: runs-on: ubuntu-latest @@ -315,7 +338,7 @@ jobs: retention-days: 30 ci-done: - needs: [ test, upload-coverage, asyncpg, psycopg-async, aiosqlite, sqlite3, pyright, ruff, go-test, go-lint, test-build ] + needs: [test, upload-coverage, asyncpg, psycopg-async, psycopg-sync, 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 abec796..8738b70 100644 --- a/README.md +++ b/README.md @@ -81,8 +81,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/)). -- **Four drivers** - `asyncpg` and `psycopg_async` for PostgreSQL, `aiosqlite` - and `sqlite3` for SQLite +- **Five drivers** - `asyncpg`, `psycopg_async`, and `psycopg_sync` 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 4fae67c..2ab1e93 100644 --- a/docs/content/_index.md +++ b/docs/content/_index.md @@ -34,7 +34,7 @@ layout: hextra-home subtitle="Generate dataclass, attrs, msgspec, or pydantic models - pick per codegen block." >}} {{< hextra/feature-card - title="Four drivers" + title="Five drivers" link="docs/guide/drivers" subtitle="asyncpg and psycopg for PostgreSQL, plus aiosqlite and sqlite3 for SQLite." >}} diff --git a/docs/content/docs/_index.md b/docs/content/docs/_index.md index 9fb9e79..0833c42 100644 --- a/docs/content/docs/_index.md +++ b/docs/content/docs/_index.md @@ -37,7 +37,7 @@ it. |---|---| | **Python** | 3.12 or newer | | **Engines** | PostgreSQL, SQLite | -| **Drivers** | `asyncpg`, `psycopg_async`, `aiosqlite`, `sqlite3` | +| **Drivers** | `asyncpg`, `psycopg_async`, `psycopg_sync`, `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 8292adc..24754c8 100644 --- a/docs/content/docs/getting-started.md +++ b/docs/content/docs/getting-started.md @@ -39,7 +39,15 @@ pip install asyncpg {{< tab name="psycopg_async" >}} ```bash -pip install "psycopg[binary]" +pip install "psycopg[binary]>=3.2" +``` + + {{< /tab >}} + + {{< tab name="psycopg_sync" >}} + +```bash +pip install "psycopg[binary]>=3.2" ``` {{< /tab >}} @@ -121,6 +129,32 @@ sql: {{< /tab >}} + {{< tab name="psycopg_sync" >}} + +```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_sync" + model_type: "dataclass" +``` + + {{< /tab >}} + {{< tab name="aiosqlite" >}} ```yaml @@ -202,6 +236,19 @@ CREATE TABLE users {{< tab name="psycopg_async" >}} +```sql +-- filename: schema.sql +CREATE TABLE users +( + id bigint PRIMARY KEY NOT NULL, + name text NOT NULL +); +``` + + {{< /tab >}} + + {{< tab name="psycopg_sync" >}} + ```sql -- filename: schema.sql CREATE TABLE users @@ -269,6 +316,19 @@ SELECT * FROM users ORDER BY name; -- name: GetUser :one SELECT * FROM users WHERE id = $1; +-- name: ListUsers :many +SELECT * FROM users ORDER BY name; +``` + + {{< /tab >}} + + {{< tab name="psycopg_sync" >}} + +```sql +-- filename: query.sql +-- name: GetUser :one +SELECT * FROM users WHERE id = $1; + -- name: ListUsers :many SELECT * FROM users ORDER BY name; ``` @@ -366,6 +426,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_sync" >}} + +```python +# models.py +@dataclasses.dataclass() +class User: + id_: int + name: str + + +# query.py +def get_user(conn: ConnectionLike, *, id_: int) -> models.User | None: + row = 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]: ... ``` @@ -494,6 +578,28 @@ asyncio.run(main()) {{< /tab >}} + {{< tab name="psycopg_sync" >}} + +```python +import psycopg + +from app.db import query + +with psycopg.connect("postgresql://user:pass@localhost/mydb") as conn: + user = query.get_user(conn, id_=1) + if user is not None: + print(user.name) + + # every row at once + users = query.list_users(conn)() + + # or iterate + for user in query.list_users(conn): + print(user.name) +``` + + {{< /tab >}} + {{< tab name="aiosqlite" >}} ```python diff --git a/docs/content/docs/guide/configuration.md b/docs/content/docs/guide/configuration.md index a10cb22..8acbe0f 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`, `psycopg_async`, `aiosqlite`, or `sqlite3` - must match the `engine`. See [Drivers](/docs/guide/drivers). | +| `sql_driver` | `asyncpg`, `psycopg_async`, `psycopg_sync`, `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,9 +88,9 @@ queries - for example a `msgspec` package and a `dataclass` package: ## Common pitfalls -- **Driver/engine mismatch.** `sql_driver: asyncpg` and `psycopg_async` require - `engine: "postgresql"`; `aiosqlite`/`sqlite3` require `engine: "sqlite"`. A - mismatch is an error. +- **Driver/engine mismatch.** `sql_driver: asyncpg`, `psycopg_async`, and + `psycopg_sync` 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 1138924..ae9f8ad 100644 --- a/docs/content/docs/guide/drivers.md +++ b/docs/content/docs/guide/drivers.md @@ -6,22 +6,25 @@ next: /docs/guide/model-types --- The `sql_driver` option picks which database library the generated code targets. -It must match your `engine`. Four drivers are supported: +It must match your `engine`. Five drivers are supported: | Driver | Engine | Style | |---|---|---| | `asyncpg` | `postgresql` | async | | `psycopg_async` | `postgresql` | async | +| `psycopg_sync` | `postgresql` | sync | | `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 +All 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. +throughput is the priority, and one of the psycopg drivers to stay in the +psycopg ecosystem (libpq, pipeline mode, PgBouncer friendliness) at comparable +speed - `psycopg_async` for asyncio code, `psycopg_sync` for plain synchronous +code. ## asyncpg (PostgreSQL) @@ -76,6 +79,26 @@ through `cursor.copy()`. rejected. {{< /callout >}} +## psycopg_sync (PostgreSQL) + +```python +import psycopg + +from app.db import queries + +with psycopg.connect("postgresql://user:pass@localhost/db") as conn: + user = queries.get_field_naming(conn, id_=1) +``` + +The synchronous flavor of the psycopg driver (Psycopg 3.2 or newer, like +`psycopg_async`): identical models, placeholders, and type contract, emitted +as plain functions with no `async`/`await`. The connection annotation is +`psycopg.Connection[psycopg.rows.TupleRow]`, and `:many` queries return the +same `QueryResults` helper - call it (`queries.list_x(conn)()`) to fetch every +row at once, or iterate it directly with a plain `for` loop. The json/jsonb +raw-text loader registration works exactly as on `psycopg_async`; the Windows +event-loop caveat does not apply. + ## aiosqlite (async SQLite) ```python diff --git a/docs/content/docs/guide/enums.md b/docs/content/docs/guide/enums.md index 550fd83..29aa101 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 PostgreSQL drivers (`asyncpg` and `psycopg_async`). + applies to the PostgreSQL drivers (`asyncpg`, `psycopg_async`, and `psycopg_sync`). {{< /callout >}} diff --git a/docs/content/docs/guide/writing-queries.md b/docs/content/docs/guide/writing-queries.md index a5313dd..a8cb9de 100644 --- a/docs/content/docs/guide/writing-queries.md +++ b/docs/content/docs/guide/writing-queries.md @@ -110,8 +110,9 @@ Variants of `:exec` that return something about the write: 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, a `psycopg.AsyncCursor` on psycopg, and a - `sqlite3.Cursor` / `aiosqlite.Cursor` on the SQLite drivers. + status tag on asyncpg, a `psycopg.AsyncCursor` / `psycopg.Cursor` on the + psycopg drivers, and a `sqlite3.Cursor` / `aiosqlite.Cursor` on the SQLite + drivers. See the [feature support matrix](/docs/reference/feature-support) for which driver supports which. @@ -129,7 +130,8 @@ 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: +psycopg streams the rows through `cursor.copy()` instead (`psycopg_sync` +emits the same body without `async`/`await`): ```python async def test_copy_from(conn: ConnectionLike, *, params: collections.abc.Sequence[TestCopyFromParams]) -> int: diff --git a/docs/content/docs/reference/configuration-options.md b/docs/content/docs/reference/configuration-options.md index 66cb09d..22fe5b2 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`, `psycopg_async`, `aiosqlite`, `sqlite3`. Must match the engine (the postgres drivers -> `postgresql`; the sqlite drivers -> `sqlite`). | +| `sql_driver` | string | *required* | One of `asyncpg`, `psycopg_async`, `psycopg_sync`, `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 4ce8d48..083716c 100644 --- a/docs/content/docs/reference/feature-support.md +++ b/docs/content/docs/reference/feature-support.md @@ -25,15 +25,15 @@ 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 | 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 | +| Command | aiosqlite | sqlite3 | asyncpg | psycopg_async | psycopg_sync | +|---|---|---|---|---|---| +| `:one` | yes | yes | yes | yes | yes | +| `:many` | yes | yes | yes | yes | yes | +| `:exec` | yes | yes | yes | yes | yes | +| `:execresult` | yes | yes | yes | yes | yes | +| `:execrows` | yes | yes | yes | yes | yes | +| `:execlastid` | yes | yes | no | no | no | +| `:copyfrom` | no | no | yes | yes | yes | See [Writing queries](/docs/guide/writing-queries) for what each command generates. @@ -64,13 +64,14 @@ query gets prepared and which knob controls it: ) ``` -- **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: +- **psycopg** (both flavors) 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) + conn = await psycopg.AsyncConnection.connect(dsn, prepare_threshold=0) # psycopg_async + conn = psycopg.connect(dsn, prepare_threshold=0) # psycopg_sync ``` - **sqlite3 / aiosqlite** expose no explicit prepare API, but the `sqlite3` @@ -90,4 +91,5 @@ query gets prepared and which knob controls it: - **`:batch*` commands** (`:batchexec`, `:batchmany`, `:batchone`) are not supported and likely never will be. - **`psycopg2` and `mysql`** drivers are not currently supported; Psycopg 3 - is, via the async `psycopg_async` driver. + is, via the `psycopg_async` (asyncio) and `psycopg_sync` (synchronous) + drivers. diff --git a/internal/config/constants.go b/internal/config/constants.go index 4ea03ce..effa76e 100644 --- a/internal/config/constants.go +++ b/internal/config/constants.go @@ -19,8 +19,16 @@ const ( SQLDriverAioSQLite SQLDriver = "aiosqlite" SQLDriverAsyncpg SQLDriver = "asyncpg" SQLDriverPsycopgAsync SQLDriver = "psycopg_async" + SQLDriverPsycopgSync SQLDriver = "psycopg_sync" ) +// IsPsycopg reports whether the driver is one of the two psycopg flavors, +// which share the psycopg module, the %(pN)s placeholder rewrite, and the +// LiteralString query-text contract. +func (dr SQLDriver) IsPsycopg() bool { + return dr == SQLDriverPsycopgAsync || dr == SQLDriverPsycopgSync +} + const ( ModelTypeDataclass ModelType = "dataclass" ModelTypeAttrs ModelType = "attrs" @@ -28,11 +36,17 @@ const ( ModelTypePydantic ModelType = "pydantic" ) +const ( + engineSQLite = "sqlite" + enginePostgreSQL = "postgresql" +) + var driversEngine = map[SQLDriver]string{ - SQLDriverSQLite: "sqlite", - SQLDriverAioSQLite: "sqlite", - SQLDriverAsyncpg: "postgresql", - SQLDriverPsycopgAsync: "postgresql", + SQLDriverSQLite: engineSQLite, + SQLDriverAioSQLite: engineSQLite, + SQLDriverAsyncpg: enginePostgreSQL, + SQLDriverPsycopgAsync: enginePostgreSQL, + SQLDriverPsycopgSync: enginePostgreSQL, } const ( diff --git a/internal/config/constants_test.go b/internal/config/constants_test.go index a8e68b8..4ec0083 100644 --- a/internal/config/constants_test.go +++ b/internal/config/constants_test.go @@ -39,6 +39,14 @@ func TestSQLDriverValidate(t *testing.T) { {name: "sqlite3 with sqlite", driver: config.SQLDriverSQLite, engine: "sqlite"}, {name: "aiosqlite with sqlite", driver: config.SQLDriverAioSQLite, engine: "sqlite"}, {name: "asyncpg with postgresql", driver: config.SQLDriverAsyncpg, engine: "postgresql"}, + {name: "psycopg_async with postgresql", driver: config.SQLDriverPsycopgAsync, engine: "postgresql"}, + {name: "psycopg_sync with postgresql", driver: config.SQLDriverPsycopgSync, engine: "postgresql"}, + { + name: "psycopg_sync with sqlite", + driver: config.SQLDriverPsycopgSync, + engine: "sqlite", + wantErr: "SQL driver psycopg_sync does not support sqlite", + }, { name: "sqlite3 with postgresql", driver: config.SQLDriverSQLite, @@ -135,3 +143,18 @@ func TestDocstringConventionValid(t *testing.T) { } } } + +func TestSQLDriverIsPsycopg(t *testing.T) { + t.Parallel() + for driver, want := range map[config.SQLDriver]bool{ + config.SQLDriverPsycopgAsync: true, + config.SQLDriverPsycopgSync: true, + config.SQLDriverAsyncpg: false, + config.SQLDriverAioSQLite: false, + config.SQLDriverSQLite: false, + } { + if got := driver.IsPsycopg(); got != want { + t.Errorf("IsPsycopg(%q) = %v, want %v", driver, got, want) + } + } +} diff --git a/internal/driver/asyncpg.go b/internal/driver/asyncpg.go index dac446d..683f79d 100644 --- a/internal/driver/asyncpg.go +++ b/internal/driver/asyncpg.go @@ -76,7 +76,7 @@ func (d *AsyncpgDriver) WriteQueryResultsClass(body *writer.CodeWriter) string { "result = await self._conn.fetch(self._sql, *self._args)", decodeRowsExpr, }) - writeAsyncNextMethod(body, "an asyncpg cursor", "self._cursor = self._conn.cursor(self._sql, *self._args)") + writeCursorNextMethod(body, true, "an asyncpg cursor", "self._cursor = self._conn.cursor(self._sql, *self._args)") return queryResultsClassName } diff --git a/internal/driver/common.go b/internal/driver/common.go index 49148be..6054f2f 100644 --- a/internal/driver/common.go +++ b/internal/driver/common.go @@ -284,19 +284,24 @@ 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 +// writeCursorNextMethod writes the cursor-backed __next__/__anext__ shared by +// the asyncpg and psycopg QueryResults classes (the sqlite drivers emit their +// own variant inline): 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) { +func writeCursorNextMethod(body *writer.CodeWriter, async bool, cursorDesc, cursorInit string) { + nextDef, iterDunder, nextDunder, stopExc, awaitKw := "def __next__", "__iter__", "__next__", "StopIteration", "" + if async { + nextDef, iterDunder, nextDunder, stopExc, awaitKw = "async def __anext__", "__aiter__", "__anext__", "StopAsyncIteration", awaitPrefix + } body.NewLine() - body.WriteIndentedLine(1, "async def __anext__(self) -> T:") - body.WriteQueryResultsNextDocstring(cursorDesc, true) + body.WriteIndentedLine(1, nextDef+"(self) -> T:") + body.WriteQueryResultsNextDocstring(cursorDesc, async) 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(3, fmt.Sprintf("self._iterator = self._cursor.%s()", iterDunder)) body.WriteIndentedLine(2, "try:") - body.WriteIndentedLine(3, "record = await self._iterator.__anext__()") - body.WriteIndentedLine(2, "except StopAsyncIteration:") + body.WriteIndentedLine(3, fmt.Sprintf("record = %sself._iterator.%s()", awaitKw, nextDunder)) + body.WriteIndentedLine(2, "except "+stopExc+":") body.WriteIndentedLine(3, "self._cursor = None") body.WriteIndentedLine(3, "self._iterator = None") body.WriteIndentedLine(3, "raise") diff --git a/internal/driver/driver.go b/internal/driver/driver.go index be908a0..c74f800 100644 --- a/internal/driver/driver.go +++ b/internal/driver/driver.go @@ -11,6 +11,7 @@ import ( const ( decodeRowsExpr = "return [self._decode_hook(row) for row in result]" queryResultsClassName = "QueryResults" + awaitPrefix = "await " ) type Driver interface { @@ -57,7 +58,9 @@ func New(conf *config.Config) (Driver, error) { case config.SQLDriverAsyncpg: return newAsyncpgDriver(), nil case config.SQLDriverPsycopgAsync: - return newPsycopgDriver(), nil + return newPsycopgDriver(true), nil + case config.SQLDriverPsycopgSync: + return newPsycopgDriver(false), nil case config.SQLDriverAioSQLite: return newSqliteDriver("aiosqlite", true), nil case config.SQLDriverSQLite: diff --git a/internal/driver/driver_test.go b/internal/driver/driver_test.go index 82962c1..4294458 100644 --- a/internal/driver/driver_test.go +++ b/internal/driver/driver_test.go @@ -16,6 +16,8 @@ func TestNew(t *testing.T) { wantAsync bool }{ {name: "asyncpg", sqlDriver: config.SQLDriverAsyncpg, wantName: "asyncpg", wantAsync: true}, + {name: "psycopg_async", sqlDriver: config.SQLDriverPsycopgAsync, wantName: "psycopg", wantAsync: true}, + {name: "psycopg_sync", sqlDriver: config.SQLDriverPsycopgSync, wantName: "psycopg", wantAsync: false}, {name: "aiosqlite", sqlDriver: config.SQLDriverAioSQLite, wantName: "aiosqlite", wantAsync: true}, {name: "sqlite3", sqlDriver: config.SQLDriverSQLite, wantName: "sqlite3", wantAsync: false}, } diff --git a/internal/driver/psycopg.go b/internal/driver/psycopg.go index 663e116..e80a08c 100644 --- a/internal/driver/psycopg.go +++ b/internal/driver/psycopg.go @@ -16,30 +16,36 @@ const ( psycopgResultType = "psycopg.rows.TupleRow" ) -// psycopgBase is the driver implementation for psycopg (Psycopg 3). +// psycopgBase is the driver implementation for both psycopg (Psycopg 3) +// flavors - psycopg_async and psycopg_sync. Psycopg's sync and async APIs +// mirror each other method for method, so all emission differences between +// the two are derived from the async flag. type psycopgBase struct { - rows *RowBuilder + async bool + 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 { +// newPsycopgDriver creates the driver for one psycopg flavor. 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(async bool) *psycopgBase { return &psycopgBase{ - rows: newRowBuilder(asyncpgNeedsConversion), + async: async, + rows: newRowBuilder(asyncpgNeedsConversion), } } -// Name returns the Python module name, "psycopg". +// Name returns the Python module name, "psycopg", for both flavors. 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 } +// IsAsync reports whether this is the psycopg_async flavor. +func (p *psycopgBase) IsAsync() bool { return p.async } // NeedsConversion reports whether a SQL type needs runtime conversion. func (p *psycopgBase) NeedsConversion(sqlType string) bool { @@ -72,7 +78,7 @@ func (p *psycopgBase) SupportsCommand(cmd string) bool { // 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), + fmt.Sprintf("type ConnectionLike = psycopg.%s[%s]", p.connClass(), psycopgResultType), } } @@ -128,20 +134,32 @@ func (p *psycopgBase) WriteConversionSetup(body *writer.CodeWriter, _ *config.Co 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. +// WriteQueryResultsClass writes the QueryResults class for psycopg :many +// queries, in its sync or async variant. 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 { + iteratorType := "Iterator" + if p.async { + iteratorType = "AsyncIterator" + } 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)") + fmt.Sprintf("self._cursor: %s | None = None", p.cursorType()), + fmt.Sprintf("self._iterator: collections.abc.%s[%s] | None = None", iteratorType, psycopgResultType), + }, psycopgResultType, p.async) + if p.async { + body.QueryResults.WriteQueryResultsAwaitFunction([]string{ + "result = await (await self._conn.execute(self._sql, self._params)).fetchall()", + decodeRowsExpr, + }) + writeCursorNextMethod(body, true, "a psycopg cursor", "self._cursor = await self._conn.execute(self._sql, self._params)") + } else { + body.QueryResults.WriteQueryResultsCallFunction([]string{ + "result = self._conn.execute(self._sql, self._params).fetchall()", + decodeRowsExpr, + }) + writeCursorNextMethod(body, false, "a psycopg cursor", "self._cursor = self._conn.execute(self._sql, self._params)") + } return queryResultsClassName } @@ -239,36 +257,8 @@ func writePsycopgCall(body *writer.CodeWriter, indent int, query model.Query, he body.WriteWrappedCall(indent, head, append(slices.Clone(leadArgs), arg), ")") } -// 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) { - head := fmt.Sprintf("row = await (await %s.execute(", conn) - args := []string{query.ConstantName} - if arg, ok := psycopgParamsArg(body, indent, query, func(dict string) string { - return head + query.ConstantName + ", " + dict + ")).fetchone()" - }); ok { - args = append(args, arg) - } - - 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) + cursorType := p.cursorType() var annotation, docRetType string switch query.Cmd { case metadata.CmdExec: @@ -288,7 +278,10 @@ func (p *psycopgBase) WriteQueryFunc(body *writer.CodeWriter, config *config.Con indent++ writeQueryDocstring(body, p, config, query, indent, docRetType) - execHead := fmt.Sprintf("await %s.execute(", conn) + execHead := conn + ".execute(" + if p.async { + execHead = awaitPrefix + execHead + } constArg := []string{query.ConstantName} switch query.Cmd { case metadata.CmdExec: @@ -305,7 +298,7 @@ func (p *psycopgBase) WriteQueryFunc(body *writer.CodeWriter, config *config.Con p.writeCopyFromBody(body, query, conn, indent) case metadata.CmdOne: - writePsycopgOneCall(body, indent, query, conn) + p.writeOneCall(body, indent, query, conn) body.WriteIndentedLine(indent, "if row is None:") body.WriteIndentedLine(indent+1, "return None") @@ -327,6 +320,63 @@ func (p *psycopgBase) WriteQueryFunc(body *writer.CodeWriter, config *config.Con } } +// connClass returns the psycopg connection class for this flavor. +func (p *psycopgBase) connClass() string { + if p.async { + return "AsyncConnection" + } + + return "Connection" +} + +// cursorType returns the annotation of the cursor conn.execute() returns. +func (p *psycopgBase) cursorType() string { + if p.async { + return fmt.Sprintf("psycopg.AsyncCursor[%s]", psycopgResultType) + } + + return fmt.Sprintf("psycopg.Cursor[%s]", psycopgResultType) +} + +// writeOneCall writes the :one fetch statement. The async flavor's tail +// closes two parentheses, which WriteWrappedCall's exploded form cannot +// express in a ruff-stable way, so its overlong case emits ruff format's +// nested-await layout instead; the sync statement is a plain chained call +// that wraps through WriteWrappedCall. +func (p *psycopgBase) writeOneCall(body *writer.CodeWriter, indent int, query model.Query, conn string) { + head := "row = " + conn + ".execute(" + tail := ").fetchone()" + if p.async { + head = "row = await (await " + conn + ".execute(" + tail = ")).fetchone()" + } + args := []string{query.ConstantName} + if arg, ok := psycopgParamsArg(body, indent, query, func(dict string) string { + return head + query.ConstantName + ", " + dict + tail + }); ok { + args = append(args, arg) + } + + if !p.async { + body.WriteWrappedCall(indent, head, args, tail) + + return + } + stmt := head + strings.Join(args, ", ") + tail + 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()") +} + // 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) { @@ -354,35 +404,40 @@ func (p *psycopgBase) writeCopyFromBody(body *writer.CodeWriter, query model.Que rowTuple = "(" + rowParts[0] + ",)" } + withKw, awaitKw := "with", "" + if p.async { + withKw, awaitKw = "async with", awaitPrefix + } + 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)) + body.WriteIndentedLine(indent, fmt.Sprintf("%s %s.cursor() as cur:", withKw, conn)) + copyCall := fmt.Sprintf("%s cur.copy(%s) as copy:", withKw, 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(copyIndent, withKw+" 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 + ")" + writeRow := awaitKw + "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, awaitKw+"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, awaitKw+"copy.write_row(") body.WriteIndentedLine(rowIndent+1, "(") for _, part := range rowParts { body.WriteIndentedLine(rowIndent+2, part+",") diff --git a/internal/driver/psycopg_test.go b/internal/driver/psycopg_test.go index fd66e2e..3d0a5ce 100644 --- a/internal/driver/psycopg_test.go +++ b/internal/driver/psycopg_test.go @@ -832,3 +832,334 @@ func TestPsycopgWriteQueryFuncBundledParams(t *testing.T) { t.Errorf("WriteQueryFunc() = %q, want %q", got, want) } } + +func psycopgSyncTestConfig() *config.Config { + conf := psycopgTestConfig() + conf.SqlDriver = config.SQLDriverPsycopgSync + + return conf +} + +func newPsycopgSync(t *testing.T) driver.Driver { + t.Helper() + d, err := driver.New(psycopgSyncTestConfig()) + if err != nil { + t.Fatalf("driver.New() error = %v", err) + } + + return d +} + +func TestPsycopgSyncDriverMetadata(t *testing.T) { + t.Parallel() + d := newPsycopgSync(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() = true, want false") + } + wantHook := []string{"type ConnectionLike = psycopg.Connection[psycopg.rows.TupleRow]"} + if got := d.TypeCheckingHook(); !slices.Equal(got, wantHook) { + t.Errorf("TypeCheckingHook() = %q, want %q", got, wantHook) + } +} + +func TestPsycopgSyncWriteQueryResultsClass(t *testing.T) { + t.Parallel() + d := newPsycopgSync(t) + w := writer.NewCodeWriter(psycopgSyncTestConfig()) + 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.Cursor[psycopg.rows.TupleRow] | None = None", + " self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None", + "", + " def __iter__(self) -> QueryResults[T]:", + " return self", + "", + " def __call__(", + " self,", + " ) -> collections.abc.Sequence[T]:", + " result = self._conn.execute(self._sql, self._params).fetchall()", + " return [self._decode_hook(row) for row in result]", + "", + " def __next__(self) -> T:", + " if self._cursor is None or self._iterator is None:", + " self._cursor = self._conn.execute(self._sql, self._params)", + " self._iterator = self._cursor.__iter__()", + " try:", + " record = self._iterator.__next__()", + " except StopIteration:", + " 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 TestPsycopgSyncWriteQueryFunc(t *testing.T) { + t.Parallel() + longName := strings.Repeat("p", 340) + cases := []struct { + name string + query model.Query + want string + }{ + { + 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{ + "def delete_author(conn: ConnectionLike, author_id: int) -> None:", + ` conn.execute(DELETE_AUTHOR, {"p1": author_id})`, + "", + }, "\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{ + "def hoist(", + " conn: ConnectionLike,", + " " + longName + ": int,", + ") -> None:", + " sql_params = {", + ` "p1": ` + longName + ",", + " }", + " conn.execute(HOIST, sql_params)", + "", + }, "\n"), + }, + { + name: "execresult returns the sync 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{ + "def update_rows(conn: ConnectionLike, id_: int) -> psycopg.Cursor[psycopg.rows.TupleRow]:", + ` return 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{ + "def update_rows(conn: ConnectionLike, id_: int) -> int:", + ` cur = conn.execute(UPDATE_ROWS, {"p1": id_})`, + " return cur.rowcount", + "", + }, "\n"), + }, + { + name: "one struct return chains fetchone", + 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{ + "def get_author(conn: ConnectionLike, id_: int) -> models.Author | None:", + ` row = 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 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{ + "def get_long(", + " conn: ConnectionLike,", + " " + longName + ": int,", + ") -> int | None:", + " sql_params = {", + ` "p1": ` + longName + ",", + " }", + " row = conn.execute(GET_LONG, sql_params).fetchone()", + " if row is None:", + " return None", + " return row[0]", + "", + }, "\n"), + }, + { + name: "one long constant wraps the chained call", + 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{ + "def get_named(conn: ConnectionLike) -> int | None:", + " row = conn.execute(", + " " + longName + ",", + " ).fetchone()", + " if row is None:", + " return None", + " return row[0]", + "", + }, "\n"), + }, + { + name: "many struct return matches the async emission", + 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 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"), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + d := newPsycopgSync(t) + conf := psycopgSyncTestConfig() + 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 TestPsycopgSyncWriteQueryFuncCopyFrom(t *testing.T) { + t.Parallel() + d := newPsycopgSync(t) + conf := psycopgSyncTestConfig() + body := writer.NewCodeWriter(conf) + 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}, + }, + }, + }}, + Returns: model.QueryValue{Type: model.PyType{Type: "int"}}, + } + d.WriteQueryFunc(body, conf, query, 0) + want := strings.Join([]string{ + "def copy_authors(conn: ConnectionLike, params: collections.abc.Sequence[CopyAuthorsParams]) -> int:", + " with conn.cursor() as cur:", + ` with cur.copy('COPY "authors" ("id", "name") FROM STDIN') as copy:`, + " for param in params:", + " copy.write_row((param.id_, param.name))", + " return cur.rowcount", + "", + }, "\n") + if got := body.String(); got != want { + t.Errorf("WriteQueryFunc() = %q, want %q", got, want) + } +} diff --git a/internal/render/imports.go b/internal/render/imports.go index 741159b..3ff59b5 100644 --- a/internal/render/imports.go +++ b/internal/render/imports.go @@ -536,7 +536,7 @@ func (r *ImportResolver) addDriverImports( } } - case config.SQLDriverPsycopgAsync: + case config.SQLDriverPsycopgAsync, config.SQLDriverPsycopgSync: // 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 diff --git a/internal/render/imports_test.go b/internal/render/imports_test.go index c728222..9af4429 100644 --- a/internal/render/imports_test.go +++ b/internal/render/imports_test.go @@ -540,6 +540,19 @@ func TestQueryImports(t *testing.T) { }, }, }, + { + name: "psycopg_sync json return forces runtime module for loaders", + conf: newImportsConfig(config.SQLDriverPsycopgSync), + 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), diff --git a/internal/render/queries.go b/internal/render/queries.go index b5bfc2e..a7734a9 100644 --- a/internal/render/queries.go +++ b/internal/render/queries.go @@ -4,7 +4,6 @@ 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" @@ -59,7 +58,7 @@ func (r *Renderer) renderQueriesModule(moduleName string, queries []model.Query) // 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 { + if r.config.SqlDriver.IsPsycopg() { constType = "typing.LiteralString" } for _, query := range queries { diff --git a/internal/render/render_queries_test.go b/internal/render/render_queries_test.go index e9bd007..0aff037 100644 --- a/internal/render/render_queries_test.go +++ b/internal/render/render_queries_test.go @@ -81,6 +81,40 @@ INSERT INTO test_items (id) VALUES (%(p1)s) async def insert_item(conn: ConnectionLike, *, id_: int) -> None: await conn.execute(INSERT_ITEM, {"p1": id_}) +`, + }, + { + name: "psycopg_sync emits synchronous bodies", + engine: "postgresql", + options: `{"package":"testpkg","sql_driver":"psycopg_sync","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.Connection[psycopg.rows.TupleRow] + + +INSERT_ITEM: typing.Final[typing.LiteralString] = """-- name: InsertItem :exec +INSERT INTO test_items (id) VALUES (%(p1)s) +""" + + +def insert_item(conn: ConnectionLike, *, id_: int) -> None: + conn.execute(INSERT_ITEM, {"p1": id_}) `, }, { diff --git a/internal/transform/queries.go b/internal/transform/queries.go index 8068195..328c299 100644 --- a/internal/transform/queries.go +++ b/internal/transform/queries.go @@ -4,7 +4,6 @@ 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" @@ -40,7 +39,7 @@ func (t *Transformer) plainParams(pluginQuery *plugin.Query) []model.QueryValue // 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 { + if t.config.SqlDriver.IsPsycopg() { seen["sql_params"]++ switch pluginQuery.Cmd { case metadata.CmdExecRows: @@ -122,7 +121,7 @@ func (t *Transformer) BuildQueries(tables []model.Table) []model.Query { // 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 && + if t.config.SqlDriver.IsPsycopg() && len(pluginQuery.Params) > 0 && query.Cmd != metadata.CmdCopyFrom { query.SQL = rewritePsycopgSQL(pluginQuery.Text) } diff --git a/internal/transform/queries_test.go b/internal/transform/queries_test.go index bf34ce5..bfbf46e 100644 --- a/internal/transform/queries_test.go +++ b/internal/transform/queries_test.go @@ -218,6 +218,20 @@ func TestBuildQueriesImplicitArgCollision(t *testing.T) { column: "_decode_hook", want: "_decode_hook", }, + // The sync flavor shares every psycopg reservation. + { + name: "sql_params collides for psycopg_sync", + driver: config.SQLDriverPsycopgSync, + column: "sql_params", + want: "sql_params_2", + }, + { + name: "row collides in a psycopg_sync one query", + driver: config.SQLDriverPsycopgSync, + cmd: ":one", + column: "row", + want: "row_2", + }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { @@ -575,6 +589,20 @@ func TestBuildQueriesPsycopgSQLRewrite(t *testing.T) { }, wantSQL: "SELECT name FROM test_authors WHERE id = %(p1)s AND name LIKE 'a%%'", }, + { + name: "parameterized query is rewritten for psycopg_sync", + driver: config.SQLDriverPsycopgSync, + 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 = %(p1)s", + }, { name: "parameterless query stays untouched", driver: config.SQLDriverPsycopgAsync, diff --git a/internal/writer/docstrings.go b/internal/writer/docstrings.go index 4815498..0e0e760 100644 --- a/internal/writer/docstrings.go +++ b/internal/writer/docstrings.go @@ -397,7 +397,7 @@ func (w *CodeWriter) WriteQueryFunctionDocstring(lvl int, query *model.Query, co // parse falls back to 0. noRows := "0" if w.docstringDriver == config.SQLDriverAioSQLite || w.docstringDriver == config.SQLDriverSQLite || - w.docstringDriver == config.SQLDriverPsycopgAsync { + w.docstringDriver.IsPsycopg() { noRows = "-1" } ret = &retDoc{ diff --git a/internal/writer/docstrings_test.go b/internal/writer/docstrings_test.go index 3aa2d59..79febfa 100644 --- a/internal/writer/docstrings_test.go +++ b/internal/writer/docstrings_test.go @@ -754,6 +754,26 @@ func TestWriteQueryFunctionDocstring(t *testing.T) { ` """`, ), }, + { + name: "execrows psycopg_sync documents rowcount's -1", + conv: config.DocstringConventionGoogle, + driver: config.SQLDriverPsycopgSync, + omitSQL: true, + write: func(w *writer.CodeWriter) { + w.WriteQueryFunctionDocstring(1, execRowsQuery, "ConnectionLike", nil, "int") + }, + want: lines( + " \"\"\"Execute SQL query with `name: TouchAuthors :execrows` and return the number of affected rows.", + ``, + ` 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`.", + ` """`, + ), + }, { name: "execrows sqlite3 pep257 normalizes sql lines", conv: config.DocstringConventionPEP257, diff --git a/noxfile.py b/noxfile.py index 1e5a16a..60f5dd7 100644 --- a/noxfile.py +++ b/noxfile.py @@ -16,6 +16,7 @@ DRIVER_PATHS = { "asyncpg": PATH_TO_PROJECT / "test" / "driver_asyncpg", "psycopg_async": PATH_TO_PROJECT / "test" / "driver_psycopg_async", + "psycopg_sync": PATH_TO_PROJECT / "test" / "driver_psycopg_sync", "aiosqlite": PATH_TO_PROJECT / "test" / "driver_aiosqlite", "sqlite3": PATH_TO_PROJECT / "test" / "driver_sqlite3", } @@ -23,7 +24,7 @@ SQLC_CONFIGS = ["sqlc.yaml"] options.default_venv_backend = "uv" -options.sessions = ["ruff_format", "asyncpg", "psycopg_async", "sqlite3", "aiosqlite", "pyright", "ruff", "pytest"] +options.sessions = ["ruff_format", "asyncpg", "psycopg_async", "psycopg_sync", "sqlite3", "aiosqlite", "pyright", "ruff", "pytest"] DEFAULT_POSTGRES_URI = os.getenv("POSTGRES_URI", "postgresql://root:187187@localhost:5432/root") @@ -156,6 +157,24 @@ def psycopg_async_check(session: nox.Session) -> None: session.run("ruff", "check", *session.posargs, DRIVER_PATHS["psycopg_async"]) +@nox.session(reuse_venv=True) +def psycopg_sync(session: nox.Session) -> None: + uv_sync(session, include_self=True, groups=["pyright", "ruff"]) + + sqlc_generate(session, "psycopg_sync") + session.run("pyright", DRIVER_PATHS["psycopg_sync"]) + session.run("ruff", "check", *session.posargs, DRIVER_PATHS["psycopg_sync"]) + + +@nox.session(reuse_venv=True) +def psycopg_sync_check(session: nox.Session) -> None: + uv_sync(session, include_self=True, groups=["pyright", "ruff"]) + + sqlc_check(session, "psycopg_sync") + session.run("pyright", DRIVER_PATHS["psycopg_sync"]) + session.run("ruff", "check", *session.posargs, DRIVER_PATHS["psycopg_sync"]) + + @nox.session(reuse_venv=True) def pyright(session: nox.Session) -> None: uv_sync(session, include_self=True, groups=["pyright"]) diff --git a/scripts/build/build.bat b/scripts/build/build.bat index 2c4b75b..9ce1823 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_psycopg_async test\driver_aiosqlite test\driver_sqlite3" +set "TARGET_DIRS=test\driver_asyncpg test\driver_psycopg_async test\driver_psycopg_sync 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 8a253be..0d92fc5 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_psycopg_async" "test/driver_aiosqlite" "test/driver_sqlite3") +TARGET_DIRS=("test/driver_asyncpg" "test/driver_psycopg_async" "test/driver_psycopg_sync" "test/driver_aiosqlite" "test/driver_sqlite3") SQLC_CONFIG_NAMES=("sqlc.yaml") # ------------------------------ diff --git a/sqlc.yaml b/sqlc.yaml index b85401a..e82f955 100644 --- a/sqlc.yaml +++ b/sqlc.yaml @@ -3,7 +3,7 @@ plugins: - name: python wasm: url: file://sqlc-gen-better-python.wasm - sha256: 1a125181baa3972863842614054215a1129e83026a9c5c1306bc25edda091782 + sha256: 390a7b913db2e1e667ff45c4db14a79aea5d4d818ffe31549c92545897a130bf sql: - schema: test/schema.sql queries: test/queries.sql diff --git a/test/conftest.py b/test/conftest.py index f0506fa..631e765 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -37,10 +37,11 @@ ASYNCPG_PATH = pathlib.Path(__file__).parent / "driver_asyncpg" PSYCOPG_ASYNC_PATH = pathlib.Path(__file__).parent / "driver_psycopg_async" +PSYCOPG_SYNC_PATH = pathlib.Path(__file__).parent / "driver_psycopg_sync" 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 +# All 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; @@ -50,6 +51,8 @@ DELETE FROM test_converters; DELETE FROM test_converter_array; DELETE FROM test_invalid_identifiers; + DELETE FROM test_enum_types; + DELETE FROM test_enum_override; DELETE FROM "3rd_party_stats"; """ @@ -125,6 +128,22 @@ async def psycopg_async_conn( await conn.close() +@pytest.fixture(scope="session") +def psycopg_sync_conn( + request: pytest.FixtureRequest, +) -> collections.abc.Generator[psycopg.Connection[psycopg.rows.TupleRow], typing.Any]: + dsn = get_dsn(request.config) + # autocommit matches the async psycopg fixture's semantics and keeps one + # failing test from poisoning the shared connection's transaction. + conn = psycopg.connect(dsn, autocommit=True) + + schema = typing.cast("typing.LiteralString", (PSYCOPG_SYNC_PATH / "schema.sql").read_text()) + conn.execute(schema) + yield conn + conn.execute(_POSTGRES_CLEANUP) + conn.close() + + @pytest.fixture(scope="class") def sqlite3_conn( request: pytest.FixtureRequest, diff --git a/test/driver_aiosqlite/sqlc-gen-better-python.wasm b/test/driver_aiosqlite/sqlc-gen-better-python.wasm index b1ae5d8..e08b1b0 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 439d72d..20e4dfc 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: 1a125181baa3972863842614054215a1129e83026a9c5c1306bc25edda091782 + sha256: 390a7b913db2e1e667ff45c4db14a79aea5d4d818ffe31549c92545897a130bf sql: - schema: schema.sql queries: queries.sql diff --git a/test/driver_asyncpg/sqlc-gen-better-python.wasm b/test/driver_asyncpg/sqlc-gen-better-python.wasm index b1ae5d8..e08b1b0 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 d6e1a86..ece1cec 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: 1a125181baa3972863842614054215a1129e83026a9c5c1306bc25edda091782 + sha256: 390a7b913db2e1e667ff45c4db14a79aea5d4d818ffe31549c92545897a130bf sql: - schema: schema.sql queries: diff --git a/test/driver_psycopg_async/sqlc-gen-better-python.wasm b/test/driver_psycopg_async/sqlc-gen-better-python.wasm index b1ae5d8..e08b1b0 100644 Binary files a/test/driver_psycopg_async/sqlc-gen-better-python.wasm 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 index 2a0f1be..8d746fa 100644 --- a/test/driver_psycopg_async/sqlc.yaml +++ b/test/driver_psycopg_async/sqlc.yaml @@ -3,7 +3,7 @@ plugins: - name: python wasm: url: file://sqlc-gen-better-python.wasm - sha256: 1a125181baa3972863842614054215a1129e83026a9c5c1306bc25edda091782 + sha256: 390a7b913db2e1e667ff45c4db14a79aea5d4d818ffe31549c92545897a130bf sql: - schema: schema.sql queries: diff --git a/test/driver_psycopg_sync/__init__.py b/test/driver_psycopg_sync/__init__.py new file mode 100644 index 0000000..242b9d5 --- /dev/null +++ b/test/driver_psycopg_sync/__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_sync/attrs/__init__.py b/test/driver_psycopg_sync/attrs/__init__.py new file mode 100644 index 0000000..242b9d5 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/attrs/classes/__init__.py b/test/driver_psycopg_sync/attrs/classes/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/attrs/classes/enums.py b/test/driver_psycopg_sync/attrs/classes/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/attrs/classes/models.py b/test/driver_psycopg_sync/attrs/classes/models.py new file mode 100644 index 0000000..b3e6ca6 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/attrs/classes/queries.py b/test/driver_psycopg_sync/attrs/classes/queries.py new file mode 100644 index 0000000..b94dc1d --- /dev/null +++ b/test/driver_psycopg_sync/attrs/classes/queries.py @@ -0,0 +1,2219 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.attrs.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns + ------- + QueryResults[T] + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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 = 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], + ) + + 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 = 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], + ) + + 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 = self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + 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 = 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_}) + + 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 = 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], + ), + ) + + 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 = 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], + ), + ) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + 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 + + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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 + + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + 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.Cursor[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.Cursor[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 self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + def update_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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 = self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + 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 = self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + 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. + + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + 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 + + """ + self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + 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 = 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_}) + + 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 = 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_}) + + 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 + + """ + self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + 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 + + """ + self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + 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 = 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) + + 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 = 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) + + 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 = self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/attrs/classes/queries_copy_override.py b/test/driver_psycopg_sync/attrs/classes/queries_copy_override.py new file mode 100644 index 0000000..e45a54e --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 + + 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. + + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + 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 = self._conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/attrs/classes/queries_enum_override.py b/test/driver_psycopg_sync/attrs/classes/queries_enum_override.py new file mode 100644 index 0000000..f18e8c6 --- /dev/null +++ b/test/driver_psycopg_sync/attrs/classes/queries_enum_override.py @@ -0,0 +1,235 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.attrs.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns + ------- + QueryResults[T] + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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 + + """ + self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + 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 = 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)}) + + 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 = 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_sync/attrs/classes/queries_field_namings.py b/test/driver_psycopg_sync/attrs/classes/queries_field_namings.py new file mode 100644 index 0000000..8e33053 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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 = self._conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + 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 = 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]) + + 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 + + """ + self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/attrs/classes/queries_invalid_identifiers.py b/test/driver_psycopg_sync/attrs/classes/queries_invalid_identifiers.py new file mode 100644 index 0000000..c966c7a --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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 + + """ + self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + 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 = 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]) + + 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 + + """ + self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + 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 = 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_sync/attrs/functions/__init__.py b/test/driver_psycopg_sync/attrs/functions/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/attrs/functions/enums.py b/test/driver_psycopg_sync/attrs/functions/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/attrs/functions/models.py b/test/driver_psycopg_sync/attrs/functions/models.py new file mode 100644 index 0000000..205a582 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/attrs/functions/queries.py b/test/driver_psycopg_sync/attrs/functions/queries.py new file mode 100644 index 0000000..69fe867 --- /dev/null +++ b/test/driver_psycopg_sync/attrs/functions/queries.py @@ -0,0 +1,2328 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.attrs.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns + ------- + QueryResults[T] + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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 = 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], + ) + + +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 = 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], + ) + + +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 = conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + +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 = 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_}) + + +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 = 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], + ), + ) + + +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 = 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], + ), + ) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +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 + + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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 + + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +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.Cursor[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.Cursor[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 conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] + The result returned when executing the query. + + """ + return conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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 = conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +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 = conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +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. + + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +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 + + """ + conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +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 = 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_}) + + +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 = 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_}) + + +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 + + """ + conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +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 + + """ + conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +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 = 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) + + +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 = 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) + + +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 = conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/attrs/functions/queries_copy_override.py b/test/driver_psycopg_sync/attrs/functions/queries_copy_override.py new file mode 100644 index 0000000..0d67d11 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 +""" + + +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. + + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +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 = conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + +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. + + """ + conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/attrs/functions/queries_enum_override.py b/test/driver_psycopg_sync/attrs/functions/queries_enum_override.py new file mode 100644 index 0000000..077d251 --- /dev/null +++ b/test/driver_psycopg_sync/attrs/functions/queries_enum_override.py @@ -0,0 +1,222 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.attrs.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns + ------- + QueryResults[T] + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns + ------- + collections.abc.Sequence[T] + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns + ------- + T + The next decoded result. + + Raises + ------ + StopIteration + When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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 + + """ + conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +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 = 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)}) + + +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 = 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_sync/attrs/functions/queries_field_namings.py b/test/driver_psycopg_sync/attrs/functions/queries_field_namings.py new file mode 100644 index 0000000..5a319d2 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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 = conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +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 = conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_}).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +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 + + """ + conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/attrs/functions/queries_invalid_identifiers.py b/test/driver_psycopg_sync/attrs/functions/queries_invalid_identifiers.py new file mode 100644 index 0000000..01de94f --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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 + + """ + conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +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 = 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]) + + +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 + + """ + conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +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 = 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_sync/attrs/ruff.toml b/test/driver_psycopg_sync/attrs/ruff.toml new file mode 100644 index 0000000..3047247 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/attrs/test_psycopg_sync_attrs_classes.py b/test/driver_psycopg_sync/attrs/test_psycopg_sync_attrs_classes.py new file mode 100644 index 0000000..858fc87 --- /dev/null +++ b/test/driver_psycopg_sync/attrs/test_psycopg_sync_attrs_classes.py @@ -0,0 +1,757 @@ +# 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 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_sync.attrs.classes import enums +from test.driver_psycopg_sync.attrs.classes import models +from test.driver_psycopg_sync.attrs.classes import queries +from test.driver_psycopg_sync.attrs.classes import queries_enum_override +from test.driver_psycopg_sync.no_row_conn import NoRowConn + + +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.fixture(scope="session") + def queries_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_sync_conn) + + @pytest.fixture(scope="session") + def queries_enum_override_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_sync_conn) + + @pytest.mark.dependency(name="TestAttrsClasses::create") + def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + 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.dependency(name="TestAttrsClasses::create_inner", depends=["TestAttrsClasses::create"]) + def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + 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.dependency(depends=["TestAttrsClasses::create_inner"], name="TestAttrsClasses::get_one") + def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_one"], name="TestAttrsClasses::get_one_none") + def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_none"], name="TestAttrsClasses::get_one_inner") + def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_one_inner"], name="TestAttrsClasses::get_one_inner_none") + def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_inner_none"], name="TestAttrsClasses::get_one_timestamp") + def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_one_timestamp"], name="TestAttrsClasses::get_one_timestamp_none") + def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_timestamp"], name="TestAttrsClasses::get_one_bytea") + def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_one_bytea"], name="TestAttrsClasses::get_one_bytea_none") + def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_one_bytea"], name="TestAttrsClasses::get_many") + def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_many"], name="TestAttrsClasses::get_many_timestamp") + def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_many_timestamp"], name="TestAttrsClasses::get_many_bytea") + def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_many_bytea"], name="TestAttrsClasses::get_embedded") + def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_embedded"], name="TestAttrsClasses::get_embedded_none") + def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_embedded_none"], name="TestAttrsClasses::get_all_embedded") + def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestAttrsClasses::get_all_embedded"], name="TestAttrsClasses::get_all_embedded_none") + def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_all_embedded"], name="TestAttrsClasses::get_many_iterator") + 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_) + with queries_obj.conn.transaction(): + for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_many_iterator"], name="TestAttrsClasses::delete") + def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.dependency(depends=["TestAttrsClasses::delete"], name="TestAttrsClasses::delete_inner") + def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestAttrsClasses::create_result") + def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestAttrsClasses::create_result"], name="TestAttrsClasses::update_result") + def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency(depends=["TestAttrsClasses::update_result"], name="TestAttrsClasses::delete_result") + def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestAttrsClasses::create_rows") + def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestAttrsClasses::create_rows"], name="TestAttrsClasses::update_rows") + def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestAttrsClasses::update_rows"], name="TestAttrsClasses::delete_rows") + def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestAttrsClasses::delete_rows"], name="TestAttrsClasses::copy_from") + def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_sync_conn: psycopg.Connection[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 = queries_obj.test_copy_from(params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries_obj.create_rows_table() + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestAttrsClasses::insert_type_override", + ) + def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_type_override", + depends=["TestAttrsClasses::insert_type_override"], + ) + def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_type_override_none", + depends=["TestAttrsClasses::get_one_type_override"], + ) + def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestAttrsClasses::get_many_type_override", + depends=["TestAttrsClasses::get_one_type_override_none"], + ) + def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_many_type_override(id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_text_type_override", + depends=["TestAttrsClasses::get_many_type_override"], + ) + def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestAttrsClasses::get_one_text_type_override_none", + depends=["TestAttrsClasses::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestAttrsClasses::get_many_text_type_override", + depends=["TestAttrsClasses::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = 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.dependency( + name="TestAttrsClasses::delete_type_override", + depends=["TestAttrsClasses::get_many_text_type_override"], + ) + def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.delete_type_override(id_=override_model.id_) + + 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.dependency(name="TestAttrsClasses::insert_enum") + def test_insert_enum(self, queries_obj: queries.Queries) -> None: + queries_obj.insert_one_test_enum_type(id_=510001, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestAttrsClasses::get_enum", depends=["TestAttrsClasses::insert_enum"]) + def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = 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.dependency(name="TestAttrsClasses::get_enum_value", depends=["TestAttrsClasses::get_enum"]) + def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=510001) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum"]) + def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum"]) + def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestAttrsClasses::get_many_enums", depends=["TestAttrsClasses::get_enum_value"]) + def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_many_test_enum_types()() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestAttrsClasses::get_many_enums"]) + def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert queries_obj.delete_one_test_enum_type(id_=510001) == 1 + + @pytest.mark.dependency(name="TestAttrsClasses::insert_enum_override") + 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. The mood is + # suite-specific: the count test filters the shared table by mood + # alone, so a row leaked by another suite using the same mood would + # break its exact-count assertion. + queries_enum_override_obj.insert_enum_override(id_=520001, mood_test="ok") + + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum_override"]) + def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=520001) + assert mood is not None + assert isinstance(mood, str) + assert mood == "ok" + + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum_override"]) + def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestAttrsClasses::list_enum_override", depends=["TestAttrsClasses::insert_enum_override"]) + 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 = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520001])() + assert len(rows) == 1 + assert rows[0].mood_test == "ok" + + @pytest.mark.dependency(depends=["TestAttrsClasses::insert_enum_override"]) + 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 for path; going through the conn + # property also covers its generated accessor. + with queries_enum_override_obj.conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520001: "ok"} + + @pytest.mark.dependency(name="TestAttrsClasses::count_enum_override", depends=["TestAttrsClasses::insert_enum_override"]) + def test_count_enum_override_by_moods(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + count = queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.OK, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.dependency(depends=["TestAttrsClasses::count_enum_override"]) + def test_delete_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520001}) + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.HAPPY]) + assert count is None diff --git a/test/driver_psycopg_sync/attrs/test_psycopg_sync_attrs_functions.py b/test/driver_psycopg_sync/attrs/test_psycopg_sync_attrs_functions.py new file mode 100644 index 0000000..e09beca --- /dev/null +++ b/test/driver_psycopg_sync/attrs/test_psycopg_sync_attrs_functions.py @@ -0,0 +1,835 @@ +# 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 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_sync.attrs.functions import enums +from test.driver_psycopg_sync.attrs.functions import models +from test.driver_psycopg_sync.attrs.functions import queries +from test.driver_psycopg_sync.attrs.functions import queries_enum_override +from test.driver_psycopg_sync.no_row_conn import NoRowConn + + +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.dependency(name="TestAttrsFunctions::create") + def test_create( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.create_one_test_postgres_type( + conn=psycopg_sync_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.dependency(name="TestAttrsFunctions::create2", depends=["TestAttrsFunctions::create"]) + def test_create_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.create_one_test_postgres_inner_type( + conn=psycopg_sync_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.dependency(depends=["TestAttrsFunctions::create2"], name="TestAttrsFunctions::get_one") + def test_get_one( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one"], name="TestAttrsFunctions::get_one_none") + def test_get_one_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_none"], name="TestAttrsFunctions::get_one_inner") + def test_get_one_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_inner"], name="TestAttrsFunctions::get_one_inner_none") + def test_get_one_inner_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_inner_none"], name="TestAttrsFunctions::get_one_timestamp") + def test_get_one_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_timestamp"], name="TestAttrsFunctions::get_one_timestamp_none") + def test_get_one_timestamp_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_timestamp_none"], name="TestAttrsFunctions::get_one_bytea") + def test_get_one_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_bytea"], name="TestAttrsFunctions::get_one_bytea_none") + def test_get_one_bytea_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_one_bytea_none"], name="TestAttrsFunctions::get_many") + def test_get_many( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_postgres_type(conn=psycopg_sync_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.dependency(depends=["TestAttrsFunctions::get_many"], name="TestAttrsFunctions::get_many_timestamp") + def test_get_many_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_timestamp_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestAttrsFunctions::get_many_timestamp"], + name="TestAttrsFunctions::get_many_bytea", + ) + def test_get_many_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_bytea_postgres_type(conn=psycopg_sync_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.dependency(depends=["TestAttrsFunctions::get_many_bytea"], name="TestAttrsFunctions::get_embedded") + def test_get_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_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.dependency(depends=["TestAttrsFunctions::get_embedded"], name="TestAttrsFunctions::get_embedded_none") + def test_get_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_embedded_none"], name="TestAttrsFunctions::get_all_embedded") + def test_get_all_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_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.dependency(depends=["TestAttrsFunctions::get_all_embedded"], name="TestAttrsFunctions::get_all_embedded_none") + def test_get_all_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestAttrsFunctions::get_all_embedded_none"], + name="TestAttrsFunctions::get_many_iterator", + ) + def test_get_many_iterator( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + with psycopg_sync_conn.transaction(): + 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.dependency(depends=["TestAttrsFunctions::get_many_iterator"], name="TestAttrsFunctions::delete") + def test_delete( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.delete_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + @pytest.mark.dependency(depends=["TestAttrsFunctions::delete"], name="TestAttrsFunctions::delete_inner") + def test_delete_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.delete_one_test_postgres_inner_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestAttrsFunctions::create_result") + def test_create_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_result_one_test_postgres_type( + conn=psycopg_sync_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.dependency(depends=["TestAttrsFunctions::create_result"], name="TestAttrsFunctions::update_result") + def test_update_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency(depends=["TestAttrsFunctions::update_result"], name="TestAttrsFunctions::delete_result") + def test_delete_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestAttrsFunctions::create_rows") + def test_create_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_rows_one_test_postgres_type( + conn=psycopg_sync_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.dependency(depends=["TestAttrsFunctions::create_rows"], name="TestAttrsFunctions::update_rows") + def test_update_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestAttrsFunctions::update_rows"], name="TestAttrsFunctions::delete_rows") + def test_delete_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestAttrsFunctions::delete_rows"], name="TestAttrsFunctions::copy_from") + def test_copy_from( + self, + psycopg_sync_conn: psycopg.Connection[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 = queries.test_copy_from(conn=psycopg_sync_conn, params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.create_rows_table(conn=psycopg_sync_conn) + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestAttrsFunctions::insert_type_override", + ) + def test_insert_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.insert_type_override(conn=psycopg_sync_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_type_override", + depends=["TestAttrsFunctions::insert_type_override"], + ) + def test_get_one_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_type_override_none", + depends=["TestAttrsFunctions::get_one_type_override"], + ) + def test_get_one_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestAttrsFunctions::get_many_type_override", + depends=["TestAttrsFunctions::get_one_type_override_none"], + ) + def test_get_many_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_text_type_override", + depends=["TestAttrsFunctions::get_many_type_override"], + ) + def test_get_one_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestAttrsFunctions::get_one_text_type_override_none", + depends=["TestAttrsFunctions::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestAttrsFunctions::get_many_text_type_override", + depends=["TestAttrsFunctions::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.dependency( + name="TestAttrsFunctions::delete_type_override", + depends=["TestAttrsFunctions::get_many_text_type_override"], + ) + def test_delete_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.delete_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + + 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.dependency(name="TestAttrsFunctions::insert_enum") + def test_insert_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries.insert_one_test_enum_type(conn=psycopg_sync_conn, id_=510002, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestAttrsFunctions::get_enum", depends=["TestAttrsFunctions::insert_enum"]) + def test_get_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_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.dependency(name="TestAttrsFunctions::get_enum_value", depends=["TestAttrsFunctions::get_enum"]) + def test_get_enum_value(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=510002) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum"]) + def test_get_enum_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_conn, id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum"]) + def test_get_enum_value_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestAttrsFunctions::get_many_enums", depends=["TestAttrsFunctions::get_enum_value"]) + def test_get_many_enums(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_many_test_enum_types(conn=psycopg_sync_conn)() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestAttrsFunctions::get_many_enums"]) + def test_delete_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries.delete_one_test_enum_type(conn=psycopg_sync_conn, id_=510002) == 1 + + @pytest.mark.dependency(name="TestAttrsFunctions::insert_enum_override") + def test_insert_enum_override(self, psycopg_sync_conn: psycopg.Connection[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. The mood is + # suite-specific: the count test filters the shared table by mood + # alone, so a row leaked by another suite using the same mood would + # break its exact-count assertion. + queries_enum_override.insert_enum_override(conn=psycopg_sync_conn, id_=520002, mood_test="24h") + + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum_override"]) + def test_get_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=520002) + assert mood is not None + assert isinstance(mood, str) + assert mood == "24h" + + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum_override"]) + def test_get_enum_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestAttrsFunctions::list_enum_override", depends=["TestAttrsFunctions::insert_enum_override"]) + def test_list_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[520002])() + assert len(rows) == 1 + assert rows[0].mood_test == "24h" + + @pytest.mark.dependency(depends=["TestAttrsFunctions::insert_enum_override"]) + def test_iterate_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[520002]) + seen: dict[int, str] = {} + # Exercise the cursor-based for path. + with psycopg_sync_conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520002: "24h"} + + @pytest.mark.dependency(name="TestAttrsFunctions::count_enum_override", depends=["TestAttrsFunctions::insert_enum_override"]) + def test_count_enum_override_by_moods(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + count = queries_enum_override.count_enum_override_by_moods(conn=psycopg_sync_conn, dollar_1=[enums.TestMood.VALUE_24H, enums.TestMood.SAD]) + assert count == 1 + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + count = queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.dependency(depends=["TestAttrsFunctions::count_enum_override"]) + def test_delete_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520002}) diff --git a/test/driver_psycopg_sync/dataclass/__init__.py b/test/driver_psycopg_sync/dataclass/__init__.py new file mode 100644 index 0000000..242b9d5 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/dataclass/classes/__init__.py b/test/driver_psycopg_sync/dataclass/classes/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/dataclass/classes/enums.py b/test/driver_psycopg_sync/dataclass/classes/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/dataclass/classes/models.py b/test/driver_psycopg_sync/dataclass/classes/models.py new file mode 100644 index 0000000..17f069d --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/dataclass/classes/queries.py b/test/driver_psycopg_sync/dataclass/classes/queries.py new file mode 100644 index 0000000..3824f20 --- /dev/null +++ b/test/driver_psycopg_sync/dataclass/classes/queries.py @@ -0,0 +1,2083 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.dataclass.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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 = 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], + ) + + 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 = 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], + ) + + 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 = self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + 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 = 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_}) + + 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 = 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], + ), + ) + + 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 = 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], + ), + ) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + 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. + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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. + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + 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.Cursor[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.Cursor[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 self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + def update_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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 = self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + 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 = self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + 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. + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + 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. + """ + self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + 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 = 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_}) + + 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 = 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_}) + + 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. + """ + self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + 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. + """ + self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + 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 = 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) + + 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 = 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) + + 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 = self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/dataclass/classes/queries_copy_override.py b/test/driver_psycopg_sync/dataclass/classes/queries_copy_override.py new file mode 100644 index 0000000..98e711d --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 + + 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. + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + 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 = self._conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/dataclass/classes/queries_enum_override.py b/test/driver_psycopg_sync/dataclass/classes/queries_enum_override.py new file mode 100644 index 0000000..50063be --- /dev/null +++ b/test/driver_psycopg_sync/dataclass/classes/queries_enum_override.py @@ -0,0 +1,207 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.dataclass.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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. + """ + self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + 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 = 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)}) + + 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 = 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_sync/dataclass/classes/queries_field_namings.py b/test/driver_psycopg_sync/dataclass/classes/queries_field_namings.py new file mode 100644 index 0000000..4fc89e4 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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 = self._conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + 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 = 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]) + + 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. + """ + self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/dataclass/classes/queries_invalid_identifiers.py b/test/driver_psycopg_sync/dataclass/classes/queries_invalid_identifiers.py new file mode 100644 index 0000000..4f1da57 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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. + """ + self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + 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 = 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]) + + 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. + """ + self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + 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 = 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_sync/dataclass/functions/__init__.py b/test/driver_psycopg_sync/dataclass/functions/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/dataclass/functions/enums.py b/test/driver_psycopg_sync/dataclass/functions/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/dataclass/functions/models.py b/test/driver_psycopg_sync/dataclass/functions/models.py new file mode 100644 index 0000000..0c1feac --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/dataclass/functions/queries.py b/test/driver_psycopg_sync/dataclass/functions/queries.py new file mode 100644 index 0000000..92061f2 --- /dev/null +++ b/test/driver_psycopg_sync/dataclass/functions/queries.py @@ -0,0 +1,2194 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.dataclass.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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 = 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], + ) + + +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 = 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], + ) + + +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 = conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + +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 = 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_}) + + +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 = 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], + ), + ) + + +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 = 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], + ), + ) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +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. + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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. + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +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.Cursor[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.Cursor[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 conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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 = conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +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 = conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +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. + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +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. + """ + conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +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 = 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_}) + + +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 = 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_}) + + +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. + """ + conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +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. + """ + conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +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 = 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) + + +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 = 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) + + +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 = conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/dataclass/functions/queries_converters.py b/test/driver_psycopg_sync/dataclass/functions/queries_converters.py new file mode 100644 index 0000000..6a4dd91 --- /dev/null +++ b/test/driver_psycopg_sync/dataclass/functions/queries_converters.py @@ -0,0 +1,267 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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]. + """ + 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)}) + + +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 = 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)}) + + +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. + """ + conn.execute(DELETE_CONVERTED, {"p1": id_}) + + +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. + """ + conn.execute(INSERT_CONVERTER_ARRAY_ROW, {"p1": id_, "p2": test.converters.encode_label(label)}) + + +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 = 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_sync/dataclass/functions/queries_copy_override.py b/test/driver_psycopg_sync/dataclass/functions/queries_copy_override.py new file mode 100644 index 0000000..af616dc --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 +""" + + +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. + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +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 = conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + +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. + """ + conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/dataclass/functions/queries_enum_override.py b/test/driver_psycopg_sync/dataclass/functions/queries_enum_override.py new file mode 100644 index 0000000..39f190c --- /dev/null +++ b/test/driver_psycopg_sync/dataclass/functions/queries_enum_override.py @@ -0,0 +1,198 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.dataclass.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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. + """ + conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +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 = 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)}) + + +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 = 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_sync/dataclass/functions/queries_field_namings.py b/test/driver_psycopg_sync/dataclass/functions/queries_field_namings.py new file mode 100644 index 0000000..75f7452 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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 = conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +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 = conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_}).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +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. + """ + conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/dataclass/functions/queries_invalid_identifiers.py b/test/driver_psycopg_sync/dataclass/functions/queries_invalid_identifiers.py new file mode 100644 index 0000000..6630971 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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. + """ + conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +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 = 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]) + + +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. + """ + conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +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 = 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_sync/dataclass/ruff.toml b/test/driver_psycopg_sync/dataclass/ruff.toml new file mode 100644 index 0000000..f37cac1 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/dataclass/test_psycopg_sync_dataclass_classes.py b/test/driver_psycopg_sync/dataclass/test_psycopg_sync_dataclass_classes.py new file mode 100644 index 0000000..e52db62 --- /dev/null +++ b/test/driver_psycopg_sync/dataclass/test_psycopg_sync_dataclass_classes.py @@ -0,0 +1,774 @@ +# 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 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_sync.dataclass.classes import enums +from test.driver_psycopg_sync.dataclass.classes import models +from test.driver_psycopg_sync.dataclass.classes import queries +from test.driver_psycopg_sync.dataclass.classes import queries_enum_override +from test.driver_psycopg_sync.no_row_conn import NoRowConn + + +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.fixture(scope="session") + def queries_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_sync_conn) + + @pytest.fixture(scope="session") + def queries_enum_override_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_sync_conn) + + @pytest.mark.dependency(name="TestDataclassClasses::create") + def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + 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.dependency(name="TestDataclassClasses::create_inner", depends=["TestDataclassClasses::create"]) + def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + 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.dependency(depends=["TestDataclassClasses::create_inner"], name="TestDataclassClasses::get_one") + def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_one"], name="TestDataclassClasses::get_one_none") + def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one_none"], name="TestDataclassClasses::get_one_inner") + def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_one_inner"], name="TestDataclassClasses::get_one_inner_none") + def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_one_inner_none"], + name="TestDataclassClasses::get_one_timestamp", + ) + def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_one_timestamp"], name="TestDataclassClasses::get_one_timestamp_none") + def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_one_timestamp_none"], + name="TestDataclassClasses::get_one_bytea", + ) + def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_one_bytea"], name="TestDataclassClasses::get_one_bytea_none") + def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestDataclassClasses::get_one_bytea_none"], name="TestDataclassClasses::get_many") + def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_many"], name="TestDataclassClasses::get_many_timestamp") + def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency( + depends=["TestDataclassClasses::get_many_timestamp"], + name="TestDataclassClasses::get_many_bytea", + ) + def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_many_bytea"], name="TestDataclassClasses::get_embedded") + def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_embedded"], name="TestDataclassClasses::get_embedded_none") + def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_embedded_none"], + name="TestDataclassClasses::get_all_embedded", + ) + def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestDataclassClasses::get_all_embedded"], name="TestDataclassClasses::get_all_embedded_none") + def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassClasses::get_all_embedded_none"], + name="TestDataclassClasses::get_many_iterator", + ) + 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_) + with queries_obj.conn.transaction(): + for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestDataclassClasses::get_many_iterator"], name="TestDataclassClasses::delete") + def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.dependency(depends=["TestDataclassClasses::delete"], name="TestDataclassClasses::delete_inner") + def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestDataclassClasses::create_result") + def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestDataclassClasses::create_result"], name="TestDataclassClasses::update_result") + def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency(depends=["TestDataclassClasses::update_result"], name="TestDataclassClasses::delete_result") + def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestDataclassClasses::create_rows") + def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestDataclassClasses::create_rows"], name="TestDataclassClasses::update_rows") + def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestDataclassClasses::update_rows"], name="TestDataclassClasses::delete_rows") + def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestDataclassClasses::delete_rows"], name="TestDataclassClasses::copy_from") + def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_sync_conn: psycopg.Connection[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 = queries_obj.test_copy_from(params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries_obj.create_rows_table() + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestDataclassClasses::insert_type_override", + ) + def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_type_override", + depends=["TestDataclassClasses::insert_type_override"], + ) + def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_type_override_none", + depends=["TestDataclassClasses::get_one_type_override"], + ) + def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestDataclassClasses::get_many_type_override", + depends=["TestDataclassClasses::get_one_type_override_none"], + ) + def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_many_type_override(id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_text_type_override", + depends=["TestDataclassClasses::get_many_type_override"], + ) + def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestDataclassClasses::get_one_text_type_override_none", + depends=["TestDataclassClasses::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestDataclassClasses::get_many_text_type_override", + depends=["TestDataclassClasses::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = 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.dependency( + name="TestDataclassClasses::delete_type_override", + depends=["TestDataclassClasses::get_many_text_type_override"], + ) + def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.delete_type_override(id_=override_model.id_) + + 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.dependency(name="TestDataclassClasses::insert_enum") + def test_insert_enum(self, queries_obj: queries.Queries) -> None: + queries_obj.insert_one_test_enum_type(id_=510003, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestDataclassClasses::get_enum", depends=["TestDataclassClasses::insert_enum"]) + def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = 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.dependency(name="TestDataclassClasses::get_enum_value", depends=["TestDataclassClasses::get_enum"]) + def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=510003) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum"]) + def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum"]) + def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestDataclassClasses::get_many_enums", depends=["TestDataclassClasses::get_enum_value"]) + def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_many_test_enum_types()() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestDataclassClasses::get_many_enums"]) + def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert queries_obj.delete_one_test_enum_type(id_=510003) == 1 + + @pytest.mark.dependency(name="TestDataclassClasses::insert_enum_override") + 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. The mood is + # suite-specific: the count test filters the shared table by mood + # alone, so a row leaked by another suite using the same mood would + # break its exact-count assertion. + queries_enum_override_obj.insert_enum_override(id_=520003, mood_test="_hidden") + + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum_override"]) + def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=520003) + assert mood is not None + assert isinstance(mood, str) + assert mood == "_hidden" + + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum_override"]) + def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestDataclassClasses::list_enum_override", depends=["TestDataclassClasses::insert_enum_override"]) + 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 = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520003])() + assert len(rows) == 1 + assert rows[0].mood_test == "_hidden" + + @pytest.mark.dependency(depends=["TestDataclassClasses::insert_enum_override"]) + 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 for path; going through the conn + # property also covers its generated accessor. + with queries_enum_override_obj.conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520003: "_hidden"} + + @pytest.mark.dependency(name="TestDataclassClasses::count_enum_override", depends=["TestDataclassClasses::insert_enum_override"]) + def test_count_enum_override_by_moods(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + count = queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.VALUE__HIDDEN, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.dependency(depends=["TestDataclassClasses::count_enum_override"]) + def test_delete_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # count_enum_override_by_moods asserts exact counts; remove the row so + # later suites against the shared database start clean. + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520003}) + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.HAPPY]) + assert count is None diff --git a/test/driver_psycopg_sync/dataclass/test_psycopg_sync_dataclass_functions.py b/test/driver_psycopg_sync/dataclass/test_psycopg_sync_dataclass_functions.py new file mode 100644 index 0000000..241df88 --- /dev/null +++ b/test/driver_psycopg_sync/dataclass/test_psycopg_sync_dataclass_functions.py @@ -0,0 +1,961 @@ +# 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 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_sync.dataclass.functions import enums +from test.driver_psycopg_sync.dataclass.functions import models +from test.driver_psycopg_sync.dataclass.functions import queries +from test.driver_psycopg_sync.dataclass.functions import queries_converters +from test.driver_psycopg_sync.dataclass.functions import queries_enum_override +from test.driver_psycopg_sync.dataclass.functions import queries_invalid_identifiers +from test.driver_psycopg_sync.no_row_conn import NoRowConn + +INVALID_IDENTIFIER_ID = 806060 +CONVERTER_ID = 710001 +CONVERTER_ARRAY_ID = 720001 + + +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.dependency(name="TestDataclassFunctions::create") + def test_create( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.create_one_test_postgres_type( + conn=psycopg_sync_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.dependency(name="TestDataclassFunctions::create2", depends=["TestDataclassFunctions::create"]) + def test_create_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.create_one_test_postgres_inner_type( + conn=psycopg_sync_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.dependency(depends=["TestDataclassFunctions::create2"], name="TestDataclassFunctions::get_one") + def test_get_one( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_one"], name="TestDataclassFunctions::get_one_none") + def test_get_one_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_one_none"], name="TestDataclassFunctions::get_one_inner") + def test_get_one_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_inner"], + name="TestDataclassFunctions::get_one_inner_none", + ) + def test_get_one_inner_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_inner_none"], + name="TestDataclassFunctions::get_one_timestamp", + ) + def test_get_one_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_timestamp"], + name="TestDataclassFunctions::get_one_timestamp_none", + ) + def test_get_one_timestamp_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_timestamp_none"], + name="TestDataclassFunctions::get_one_bytea", + ) + def test_get_one_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_one_bytea"], + name="TestDataclassFunctions::get_one_bytea_none", + ) + def test_get_one_bytea_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_one_bytea_none"], name="TestDataclassFunctions::get_many") + def test_get_many( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestDataclassFunctions::get_many"], + name="TestDataclassFunctions::get_many_timestamp", + ) + def test_get_many_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_timestamp_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestDataclassFunctions::get_many_timestamp"], + name="TestDataclassFunctions::get_many_bytea", + ) + def test_get_many_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_bytea_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestDataclassFunctions::get_many_bytea"], + name="TestDataclassFunctions::get_embedded", + ) + def test_get_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestDataclassFunctions::get_embedded"], + name="TestDataclassFunctions::get_embedded_none", + ) + def test_get_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_embedded_none"], + name="TestDataclassFunctions::get_all_embedded", + ) + def test_get_all_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestDataclassFunctions::get_all_embedded"], + name="TestDataclassFunctions::get_all_embedded_none", + ) + def test_get_all_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_all_embedded_none"], + name="TestDataclassFunctions::get_many_iterator", + ) + def test_get_many_iterator( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + with psycopg_sync_conn.transaction(): + for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::get_many_iterator"], + name="TestDataclassFunctions::delete", + ) + def test_delete( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.delete_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + @pytest.mark.dependency(depends=["TestDataclassFunctions::delete"], name="TestDataclassFunctions::delete_inner") + def test_delete_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.delete_one_test_postgres_inner_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestDataclassFunctions::create_result") + def test_create_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_result_one_test_postgres_type( + conn=psycopg_sync_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.dependency( + depends=["TestDataclassFunctions::create_result"], + name="TestDataclassFunctions::update_result", + ) + def test_update_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency( + depends=["TestDataclassFunctions::update_result"], + name="TestDataclassFunctions::delete_result", + ) + def test_delete_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestDataclassFunctions::create_rows") + def test_create_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_rows_one_test_postgres_type( + conn=psycopg_sync_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.dependency(depends=["TestDataclassFunctions::create_rows"], name="TestDataclassFunctions::update_rows") + def test_update_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestDataclassFunctions::update_rows"], name="TestDataclassFunctions::delete_rows") + def test_delete_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestDataclassFunctions::delete_rows"], name="TestDataclassFunctions::copy_from") + def test_copy_from( + self, + psycopg_sync_conn: psycopg.Connection[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 = queries.test_copy_from(conn=psycopg_sync_conn, params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.create_rows_table(conn=psycopg_sync_conn) + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestDataclassFunctions::insert_type_override", + ) + def test_insert_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.insert_type_override(conn=psycopg_sync_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_type_override", + depends=["TestDataclassFunctions::insert_type_override"], + ) + def test_get_one_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_type_override_none", + depends=["TestDataclassFunctions::get_one_type_override"], + ) + def test_get_one_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestDataclassFunctions::get_many_type_override", + depends=["TestDataclassFunctions::get_one_type_override_none"], + ) + def test_get_many_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_text_type_override", + depends=["TestDataclassFunctions::get_many_type_override"], + ) + def test_get_one_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestDataclassFunctions::get_one_text_type_override_none", + depends=["TestDataclassFunctions::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestDataclassFunctions::get_many_text_type_override", + depends=["TestDataclassFunctions::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.dependency( + name="TestDataclassFunctions::delete_type_override", + depends=["TestDataclassFunctions::get_many_text_type_override"], + ) + def test_delete_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.delete_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + + @pytest.mark.dependency(name="TestDataclassFunctions::insert_invalid_identifiers") + def test_insert_invalid_identifiers(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries_invalid_identifiers.insert_invalid_identifiers(conn=psycopg_sync_conn, id_=INVALID_IDENTIFIER_ID, column_3p_="3%", new_notes="hello") + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_invalid_identifiers"]) + def test_get_invalid_identifiers(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + row = queries_invalid_identifiers.get_invalid_identifiers(conn=psycopg_sync_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.dependency(depends=["TestDataclassFunctions::insert_invalid_identifiers"]) + def test_get_invalid_identifiers_not_found(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries_invalid_identifiers.get_invalid_identifiers(conn=psycopg_sync_conn, id_=INVALID_IDENTIFIER_ID - 1) is None + + @pytest.mark.dependency(name="TestDataclassFunctions::insert_third_party_stat") + def test_insert_third_party_stat(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries_invalid_identifiers.insert_third_party_stat(conn=psycopg_sync_conn, id_=INVALID_IDENTIFIER_ID, total=7) + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_third_party_stat"]) + def test_get_third_party_stat(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + stat = queries_invalid_identifiers.get_third_party_stat(conn=psycopg_sync_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.dependency(depends=["TestDataclassFunctions::insert_third_party_stat"]) + def test_get_third_party_stat_not_found(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries_invalid_identifiers.get_third_party_stat(conn=psycopg_sync_conn, id_=INVALID_IDENTIFIER_ID - 1) is None + + 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.dependency(name="TestDataclassFunctions::insert_enum") + def test_insert_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries.insert_one_test_enum_type(conn=psycopg_sync_conn, id_=510004, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestDataclassFunctions::get_enum", depends=["TestDataclassFunctions::insert_enum"]) + def test_get_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_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.dependency(name="TestDataclassFunctions::get_enum_value", depends=["TestDataclassFunctions::get_enum"]) + def test_get_enum_value(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=510004) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum"]) + def test_get_enum_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_conn, id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum"]) + def test_get_enum_value_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestDataclassFunctions::get_many_enums", depends=["TestDataclassFunctions::get_enum_value"]) + def test_get_many_enums(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_many_test_enum_types(conn=psycopg_sync_conn)() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestDataclassFunctions::get_many_enums"]) + def test_delete_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries.delete_one_test_enum_type(conn=psycopg_sync_conn, id_=510004) == 1 + + @pytest.mark.dependency(name="TestDataclassFunctions::insert_enum_override") + def test_insert_enum_override(self, psycopg_sync_conn: psycopg.Connection[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. + queries_enum_override.insert_enum_override(conn=psycopg_sync_conn, id_=520004, mood_test="happy") + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum_override"]) + def test_get_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=520004) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum_override"]) + def test_get_enum_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestDataclassFunctions::list_enum_override", depends=["TestDataclassFunctions::insert_enum_override"]) + def test_list_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[520004])() + assert len(rows) == 1 + assert rows[0].mood_test == "happy" + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_enum_override"]) + def test_iterate_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[520004]) + seen: dict[int, str] = {} + # Exercise the cursor-based for path. + with psycopg_sync_conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520004: "happy"} + + @pytest.mark.dependency(name="TestDataclassFunctions::count_enum_override", depends=["TestDataclassFunctions::insert_enum_override"]) + def test_count_enum_override_by_moods(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + count = queries_enum_override.count_enum_override_by_moods(conn=psycopg_sync_conn, dollar_1=[enums.TestMood.HAPPY, enums.TestMood.SAD]) + assert count == 1 + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + count = queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.dependency(depends=["TestDataclassFunctions::count_enum_override"]) + def test_delete_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # count_enum_override_by_moods asserts exact counts; remove the row so + # later suites against the shared database start clean. + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520004}) + + @pytest.mark.dependency(name="TestDataclassFunctions::insert_converted") + def test_insert_converted(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries_converters.insert_converted( + conn=psycopg_sync_conn, + id_=CONVERTER_ID, + prefs=converters.Preferences(theme="dark", notifications=True), + maybe_prefs=None, + tags=frozenset({"b", "a"}), + ) + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converted"]) + def test_get_converted(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + row = queries_converters.get_converted(conn=psycopg_sync_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.dependency(depends=["TestDataclassFunctions::insert_converted"]) + def test_get_converted_not_found(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries_converters.get_converted(conn=psycopg_sync_conn, id_=CONVERTER_ID + 999) is None + + @pytest.mark.dependency(name="TestDataclassFunctions::converted_nullable", depends=["TestDataclassFunctions::insert_converted"]) + def test_converted_nullable_roundtrip(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries_converters.insert_converted( + conn=psycopg_sync_conn, + id_=CONVERTER_ID + 1, + prefs=converters.Preferences(theme="light", notifications=False), + maybe_prefs=converters.Preferences(theme="sepia", notifications=True), + tags=frozenset(), + ) + row = queries_converters.get_converted(conn=psycopg_sync_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.dependency(name="TestDataclassFunctions::list_converted", depends=["TestDataclassFunctions::insert_converted"]) + def test_list_converted_by_tags(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # The converted value is passed as a QueryResults argument. + rows = queries_converters.list_converted_by_tags(conn=psycopg_sync_conn, tags=frozenset({"a", "b"}))() + assert rows == [CONVERTER_ID] + + @pytest.mark.dependency(name="TestDataclassFunctions::iterate_converted", depends=["TestDataclassFunctions::insert_converted"]) + def test_iterate_converted_by_tags(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + results = queries_converters.list_converted_by_tags(conn=psycopg_sync_conn, tags=frozenset({"a", "b"})) + # Exercise the cursor-based for path. + with psycopg_sync_conn.transaction(): + seen = list(results) + assert seen == [CONVERTER_ID] + + @pytest.mark.dependency(depends=["TestDataclassFunctions::converted_nullable", "TestDataclassFunctions::list_converted", "TestDataclassFunctions::iterate_converted"]) + def test_delete_converted(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries_converters.delete_converted(conn=psycopg_sync_conn, id_=CONVERTER_ID) + queries_converters.delete_converted(conn=psycopg_sync_conn, id_=CONVERTER_ID + 1) + assert queries_converters.get_converted(conn=psycopg_sync_conn, id_=CONVERTER_ID) is None + + @pytest.mark.dependency(name="TestDataclassFunctions::insert_converter_array") + def test_insert_converter_array(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # db_type converter on a domain-typed column: the scalar label converts via to_db. + queries_converters.insert_converter_array_row(conn=psycopg_sync_conn, id_=CONVERTER_ARRAY_ID, label=pathlib.PurePosixPath("a/b")) + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converter_array"]) + def test_get_converter_array_label(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + label = queries_converters.get_converter_array_label(conn=psycopg_sync_conn, id_=CONVERTER_ARRAY_ID) + assert label == pathlib.PurePosixPath("a/b") + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converter_array"]) + def test_get_converter_array_label_not_found(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries_converters.get_converter_array_label(conn=psycopg_sync_conn, id_=CONVERTER_ARRAY_ID + 999) is None + + @pytest.mark.dependency(depends=["TestDataclassFunctions::insert_converter_array"]) + def test_find_converter_array_by_labels(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # Every element of the ANY($1::converter_label[]) array passes through + # the db_type converter before reaching the driver. + rows = queries_converters.find_converter_array_by_labels( + conn=psycopg_sync_conn, + dollar_1=[pathlib.PurePosixPath("a/b"), pathlib.PurePosixPath("c/d")], + )() + assert rows == [CONVERTER_ARRAY_ID] diff --git a/test/driver_psycopg_sync/msgspec/__init__.py b/test/driver_psycopg_sync/msgspec/__init__.py new file mode 100644 index 0000000..242b9d5 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/msgspec/classes/__init__.py b/test/driver_psycopg_sync/msgspec/classes/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/msgspec/classes/enums.py b/test/driver_psycopg_sync/msgspec/classes/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/msgspec/classes/models.py b/test/driver_psycopg_sync/msgspec/classes/models.py new file mode 100644 index 0000000..9f5496d --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/msgspec/classes/queries.py b/test/driver_psycopg_sync/msgspec/classes/queries.py new file mode 100644 index 0000000..2108f6b --- /dev/null +++ b/test/driver_psycopg_sync/msgspec/classes/queries.py @@ -0,0 +1,2074 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.msgspec.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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 = 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], + ) + + 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 = 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], + ) + + 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 = self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + 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 = 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_}) + + 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 = 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], + ), + ) + + 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 = 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], + ), + ) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + 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. + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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. + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + 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.Cursor[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.Cursor[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 self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + def update_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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 = self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + 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 = self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + 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. + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + 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. + """ + self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + 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 = 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_}) + + 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 = 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_}) + + 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. + """ + self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + 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. + """ + self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + 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 = 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) + + 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 = 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) + + 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 = self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/msgspec/classes/queries_copy_override.py b/test/driver_psycopg_sync/msgspec/classes/queries_copy_override.py new file mode 100644 index 0000000..c813eb4 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 + + 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. + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + 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 = self._conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/msgspec/classes/queries_enum_override.py b/test/driver_psycopg_sync/msgspec/classes/queries_enum_override.py new file mode 100644 index 0000000..211735e --- /dev/null +++ b/test/driver_psycopg_sync/msgspec/classes/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] = ( + "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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.msgspec.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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. + """ + self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + 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 = 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)}) + + 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 = 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_sync/msgspec/classes/queries_field_namings.py b/test/driver_psycopg_sync/msgspec/classes/queries_field_namings.py new file mode 100644 index 0000000..cbf9bd6 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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 = self._conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + 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 = 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]) + + 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. + """ + self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/msgspec/classes/queries_invalid_identifiers.py b/test/driver_psycopg_sync/msgspec/classes/queries_invalid_identifiers.py new file mode 100644 index 0000000..25e8857 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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. + """ + self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + 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 = 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]) + + 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. + """ + self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + 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 = 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_sync/msgspec/functions/__init__.py b/test/driver_psycopg_sync/msgspec/functions/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/msgspec/functions/enums.py b/test/driver_psycopg_sync/msgspec/functions/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/msgspec/functions/models.py b/test/driver_psycopg_sync/msgspec/functions/models.py new file mode 100644 index 0000000..9cbd1f9 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/msgspec/functions/queries.py b/test/driver_psycopg_sync/msgspec/functions/queries.py new file mode 100644 index 0000000..001789d --- /dev/null +++ b/test/driver_psycopg_sync/msgspec/functions/queries.py @@ -0,0 +1,2153 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.msgspec.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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 = 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], + ) + + +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 = 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], + ) + + +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 = conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + +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 = 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_}) + + +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 = 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], + ), + ) + + +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 = 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], + ), + ) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +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. + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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. + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +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.Cursor[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.Cursor[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 conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow] -- The result returned when executing the query. + """ + return conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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 = conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +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 = conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +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. + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +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. + """ + conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +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 = 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_}) + + +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 = 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_}) + + +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. + """ + conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +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. + """ + conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +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 = 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) + + +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 = 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) + + +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 = conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/msgspec/functions/queries_copy_override.py b/test/driver_psycopg_sync/msgspec/functions/queries_copy_override.py new file mode 100644 index 0000000..2be0a77 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 +""" + + +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. + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +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 = conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + +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. + """ + conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/msgspec/functions/queries_enum_override.py b/test/driver_psycopg_sync/msgspec/functions/queries_enum_override.py new file mode 100644 index 0000000..50b3b4b --- /dev/null +++ b/test/driver_psycopg_sync/msgspec/functions/queries_enum_override.py @@ -0,0 +1,190 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.msgspec.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration -- When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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. + """ + conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +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 = 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)}) + + +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 = 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_sync/msgspec/functions/queries_field_namings.py b/test/driver_psycopg_sync/msgspec/functions/queries_field_namings.py new file mode 100644 index 0000000..87d69cd --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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 = conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +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 = conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_}).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +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. + """ + conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/msgspec/functions/queries_invalid_identifiers.py b/test/driver_psycopg_sync/msgspec/functions/queries_invalid_identifiers.py new file mode 100644 index 0000000..448c8a0 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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. + """ + conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +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 = 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]) + + +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. + """ + conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +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 = 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_sync/msgspec/ruff.toml b/test/driver_psycopg_sync/msgspec/ruff.toml new file mode 100644 index 0000000..876ccf0 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/msgspec/test_psycopg_sync_msgspec_classes.py b/test/driver_psycopg_sync/msgspec/test_psycopg_sync_msgspec_classes.py new file mode 100644 index 0000000..9e3f23a --- /dev/null +++ b/test/driver_psycopg_sync/msgspec/test_psycopg_sync_msgspec_classes.py @@ -0,0 +1,771 @@ +# 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 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_sync.msgspec.classes import enums +from test.driver_psycopg_sync.msgspec.classes import models +from test.driver_psycopg_sync.msgspec.classes import queries +from test.driver_psycopg_sync.msgspec.classes import queries_enum_override +from test.driver_psycopg_sync.no_row_conn import NoRowConn + + +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.fixture(scope="session") + def queries_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_sync_conn) + + @pytest.mark.dependency(name="TestMsgspecClasses::create") + def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + 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.dependency(name="TestMsgspecClasses::create_inner", depends=["TestMsgspecClasses::create"]) + def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + 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.dependency(depends=["TestMsgspecClasses::create_inner"], name="TestMsgspecClasses::get_one") + def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_one"], name="TestMsgspecClasses::get_one_none") + def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one_none"], name="TestMsgspecClasses::get_one_inner") + def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_one_inner"], name="TestMsgspecClasses::get_one_inner_none") + def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_one_inner_none"], + name="TestMsgspecClasses::get_one_timestamp", + ) + def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_one_timestamp"], name="TestMsgspecClasses::get_one_timestamp_none") + def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_one_timestamp_none"], + name="TestMsgspecClasses::get_one_bytea", + ) + def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_one_bytea"], name="TestMsgspecClasses::get_one_bytea_none") + def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_one_bytea_none"], name="TestMsgspecClasses::get_many") + def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_many"], name="TestMsgspecClasses::get_many_timestamp") + def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency( + depends=["TestMsgspecClasses::get_many_timestamp"], + name="TestMsgspecClasses::get_many_bytea", + ) + def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_many_bytea"], name="TestMsgspecClasses::get_embedded") + def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_embedded"], name="TestMsgspecClasses::get_embedded_none") + def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_embedded_none"], + name="TestMsgspecClasses::get_all_embedded", + ) + def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::get_all_embedded"], name="TestMsgspecClasses::get_all_embedded_none") + def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecClasses::get_all_embedded_none"], + name="TestMsgspecClasses::get_many_iterator", + ) + 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_) + with queries_obj.conn.transaction(): + for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_many_iterator"], name="TestMsgspecClasses::delete") + def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.dependency(depends=["TestMsgspecClasses::delete"], name="TestMsgspecClasses::delete_inner") + def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestMsgspecClasses::create_result") + def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::create_result"], name="TestMsgspecClasses::update_result") + def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency(depends=["TestMsgspecClasses::update_result"], name="TestMsgspecClasses::delete_result") + def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestMsgspecClasses::create_rows") + def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestMsgspecClasses::create_rows"], name="TestMsgspecClasses::update_rows") + def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestMsgspecClasses::update_rows"], name="TestMsgspecClasses::delete_rows") + def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestMsgspecClasses::delete_rows"], name="TestMsgspecClasses::copy_from") + def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_sync_conn: psycopg.Connection[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 = queries_obj.test_copy_from(params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries_obj.create_rows_table() + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestMsgspecClasses::insert_type_override", + ) + def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_type_override", + depends=["TestMsgspecClasses::insert_type_override"], + ) + def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_type_override_none", + depends=["TestMsgspecClasses::get_one_type_override"], + ) + def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestMsgspecClasses::get_many_type_override", + depends=["TestMsgspecClasses::get_one_type_override_none"], + ) + def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_many_type_override(id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_text_type_override", + depends=["TestMsgspecClasses::get_many_type_override"], + ) + def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestMsgspecClasses::get_one_text_type_override_none", + depends=["TestMsgspecClasses::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestMsgspecClasses::get_many_text_type_override", + depends=["TestMsgspecClasses::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = 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.dependency( + name="TestMsgspecClasses::delete_type_override", + depends=["TestMsgspecClasses::get_many_text_type_override"], + ) + def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.delete_type_override(id_=override_model.id_) + + 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.dependency(name="TestMsgspecClasses::insert_enum") + def test_insert_enum(self, queries_obj: queries.Queries) -> None: + queries_obj.insert_one_test_enum_type(id_=510005, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestMsgspecClasses::get_enum", depends=["TestMsgspecClasses::insert_enum"]) + def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = 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.dependency(name="TestMsgspecClasses::get_enum_value", depends=["TestMsgspecClasses::get_enum"]) + def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=510005) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum"]) + def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum"]) + def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestMsgspecClasses::get_many_enums", depends=["TestMsgspecClasses::get_enum_value"]) + def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_many_test_enum_types()() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestMsgspecClasses::get_many_enums"]) + def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert queries_obj.delete_one_test_enum_type(id_=510005) == 1 + + @pytest.fixture(scope="session") + def queries_enum_override_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_sync_conn) + + @pytest.mark.dependency(name="TestMsgspecClasses::insert_enum_override") + 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. + queries_enum_override_obj.insert_enum_override(id_=520005, mood_test="sad") + + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum_override"]) + def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=520005) + assert mood is not None + assert isinstance(mood, str) + assert mood == "sad" + + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum_override"]) + def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestMsgspecClasses::list_enum_override", depends=["TestMsgspecClasses::insert_enum_override"]) + 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 = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520005])() + assert len(rows) == 1 + assert rows[0].mood_test == "sad" + + @pytest.mark.dependency(depends=["TestMsgspecClasses::insert_enum_override"]) + 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 for path; going through the conn + # property also covers its generated accessor. + with queries_enum_override_obj.conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520005: "sad"} + + @pytest.mark.dependency(name="TestMsgspecClasses::count_enum_override", depends=["TestMsgspecClasses::insert_enum_override"]) + 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 = queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.SAD, enums.TestMood.OK]) + assert count == 1 + + @pytest.mark.dependency(depends=["TestMsgspecClasses::count_enum_override"]) + def test_cleanup_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520005}) + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.SAD]) + assert count is None diff --git a/test/driver_psycopg_sync/msgspec/test_psycopg_sync_msgspec_functions.py b/test/driver_psycopg_sync/msgspec/test_psycopg_sync_msgspec_functions.py new file mode 100644 index 0000000..8eeb0b8 --- /dev/null +++ b/test/driver_psycopg_sync/msgspec/test_psycopg_sync_msgspec_functions.py @@ -0,0 +1,854 @@ +# 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 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_sync.msgspec.functions import enums +from test.driver_psycopg_sync.msgspec.functions import models +from test.driver_psycopg_sync.msgspec.functions import queries +from test.driver_psycopg_sync.msgspec.functions import queries_copy_override +from test.driver_psycopg_sync.msgspec.functions import queries_enum_override +from test.driver_psycopg_sync.no_row_conn import NoRowConn + + +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.dependency(name="TestMsgspecFunctions::create") + def test_create( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.create_one_test_postgres_type( + conn=psycopg_sync_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.dependency(name="TestMsgspecFunctions::create2", depends=["TestMsgspecFunctions::create"]) + def test_create_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.create_one_test_postgres_inner_type( + conn=psycopg_sync_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.dependency(depends=["TestMsgspecFunctions::create2"], name="TestMsgspecFunctions::get_one") + def test_get_one( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one"], name="TestMsgspecFunctions::get_one_none") + def test_get_one_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_none"], name="TestMsgspecFunctions::get_one_inner") + def test_get_one_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_inner"], name="TestMsgspecFunctions::get_one_inner_none") + def test_get_one_inner_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_one_inner_none"], + name="TestMsgspecFunctions::get_one_timestamp", + ) + def test_get_one_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_timestamp"], name="TestMsgspecFunctions::get_one_timestamp_none") + def test_get_one_timestamp_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_one_timestamp_none"], + name="TestMsgspecFunctions::get_one_bytea", + ) + def test_get_one_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_bytea"], name="TestMsgspecFunctions::get_one_bytea_none") + def test_get_one_bytea_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_one_bytea_none"], name="TestMsgspecFunctions::get_many") + def test_get_many( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestMsgspecFunctions::get_many"], + name="TestMsgspecFunctions::get_many_timestamp", + ) + def test_get_many_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_timestamp_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestMsgspecFunctions::get_many_timestamp"], + name="TestMsgspecFunctions::get_many_bytea", + ) + def test_get_many_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_bytea_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestMsgspecFunctions::get_many_bytea"], + name="TestMsgspecFunctions::get_embedded", + ) + def test_get_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_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.dependency(depends=["TestMsgspecFunctions::get_embedded"], name="TestMsgspecFunctions::get_embedded_none") + def test_get_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_embedded_none"], + name="TestMsgspecFunctions::get_all_embedded", + ) + def test_get_all_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestMsgspecFunctions::get_all_embedded"], + name="TestMsgspecFunctions::get_all_embedded_none", + ) + def test_get_all_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestMsgspecFunctions::get_all_embedded_none"], + name="TestMsgspecFunctions::get_many_iterator", + ) + def test_get_many_iterator( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + with psycopg_sync_conn.transaction(): + for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_many_iterator"], name="TestMsgspecFunctions::delete") + def test_delete( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.delete_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::delete"], name="TestMsgspecFunctions::delete_inner") + def test_delete_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.delete_one_test_postgres_inner_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestMsgspecFunctions::create_result") + def test_create_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_result_one_test_postgres_type( + conn=psycopg_sync_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.dependency(depends=["TestMsgspecFunctions::create_result"], name="TestMsgspecFunctions::update_result") + def test_update_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::update_result"], name="TestMsgspecFunctions::delete_result") + def test_delete_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestMsgspecFunctions::create_rows") + def test_create_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_rows_one_test_postgres_type( + conn=psycopg_sync_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.dependency(depends=["TestMsgspecFunctions::create_rows"], name="TestMsgspecFunctions::update_rows") + def test_update_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::update_rows"], name="TestMsgspecFunctions::delete_rows") + def test_delete_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::delete_rows"], name="TestMsgspecFunctions::copy_from") + def test_copy_from( + self, + psycopg_sync_conn: psycopg.Connection[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 = queries.test_copy_from(conn=psycopg_sync_conn, params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.create_rows_table(conn=psycopg_sync_conn) + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestMsgspecFunctions::insert_type_override", + ) + def test_insert_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.insert_type_override(conn=psycopg_sync_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_type_override", + depends=["TestMsgspecFunctions::insert_type_override"], + ) + def test_get_one_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_type_override_none", + depends=["TestMsgspecFunctions::get_one_type_override"], + ) + def test_get_one_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_many_type_override", + depends=["TestMsgspecFunctions::get_one_type_override_none"], + ) + def test_get_many_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_text_type_override", + depends=["TestMsgspecFunctions::get_many_type_override"], + ) + def test_get_one_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_one_text_type_override_none", + depends=["TestMsgspecFunctions::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestMsgspecFunctions::get_many_text_type_override", + depends=["TestMsgspecFunctions::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.dependency( + name="TestMsgspecFunctions::delete_type_override", + depends=["TestMsgspecFunctions::get_many_text_type_override"], + ) + def test_delete_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.delete_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + + 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.dependency(name="TestMsgspecFunctions::insert_enum") + def test_insert_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries.insert_one_test_enum_type(conn=psycopg_sync_conn, id_=424242, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestMsgspecFunctions::get_enum", depends=["TestMsgspecFunctions::insert_enum"]) + def test_get_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_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.dependency(name="TestMsgspecFunctions::get_enum_value", depends=["TestMsgspecFunctions::get_enum"]) + def test_get_enum_value(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=424242) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum"]) + def test_get_enum_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_conn, id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum"]) + def test_get_enum_value_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestMsgspecFunctions::get_many_enums", depends=["TestMsgspecFunctions::get_enum_value"]) + def test_get_many_enums(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_many_test_enum_types(conn=psycopg_sync_conn)() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::get_many_enums"]) + def test_delete_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries.delete_one_test_enum_type(conn=psycopg_sync_conn, id_=424242) == 1 + + @pytest.mark.dependency(name="TestMsgspecFunctions::insert_enum_override") + def test_insert_enum_override(self, psycopg_sync_conn: psycopg.Connection[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. The mood + # matches the sibling msgspec classes suite (whose row is deleted + # before this file runs) and stays distinct from the other suites: the + # count test filters the shared table by mood alone, so a row leaked + # by a suite using the same mood would break its exact-count assertion. + queries_enum_override.insert_enum_override(conn=psycopg_sync_conn, id_=434343, mood_test="sad") + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + def test_get_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=434343) + assert mood is not None + assert isinstance(mood, str) + assert mood == "sad" + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + def test_get_enum_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestMsgspecFunctions::list_enum_override", depends=["TestMsgspecFunctions::insert_enum_override"]) + def test_list_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[434343])() + assert len(rows) == 1 + assert rows[0].mood_test == "sad" + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + def test_iterate_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[434343]) + seen: dict[int, str] = {} + # Exercise the cursor-based for path. + with psycopg_sync_conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {434343: "sad"} + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + def test_list_enum_override_by_ids_empty(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + rows = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[987654321])() + assert rows == [] + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + def test_count_enum_override_by_moods(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + count = queries_enum_override.count_enum_override_by_moods(conn=psycopg_sync_conn, dollar_1=[enums.TestMood.SAD, enums.TestMood.OK]) + assert count == 1 + + def test_count_enum_override_by_moods_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + count = queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.dependency(name="TestMsgspecFunctions::copy_override") + def test_copy_override_rows(self, psycopg_sync_conn: psycopg.Connection[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 = queries_copy_override.copy_override_rows(conn=psycopg_sync_conn, params=params) + assert inserted == len(params) + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::copy_override"]) + def test_count_and_delete_copy_override_rows(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + copied_rows = 2 + count = queries_copy_override.count_copy_override_rows(conn=psycopg_sync_conn) + assert count == copied_rows + queries_copy_override.delete_copy_override_rows(conn=psycopg_sync_conn) + count = queries_copy_override.count_copy_override_rows(conn=psycopg_sync_conn) + assert count == 0 + + @pytest.mark.dependency(depends=["TestMsgspecFunctions::insert_enum_override"]) + def test_delete_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # Later suites count test_enum_override rows by mood; drop this one. + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 434343}) + + def test_count_copy_override_rows_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + count = queries_copy_override.count_copy_override_rows(conn=conn) + assert count is None diff --git a/test/driver_psycopg_sync/no_row_conn.py b/test/driver_psycopg_sync/no_row_conn.py new file mode 100644 index 0000000..511f2ab --- /dev/null +++ b/test/driver_psycopg_sync/no_row_conn.py @@ -0,0 +1,48 @@ +# 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. +"""Shared connection stub for exercising the generated not-found branches.""" + +from __future__ import annotations + + +class NoRowCursor: + """Cursor stub whose fetchone never finds a row.""" + + @staticmethod + def fetchone() -> None: + """Return None, exactly like a cursor over an empty result set.""" + + +class NoRowConn: + """Connection stub whose queries never find a row.""" + + # `SELECT count(*)` always returns exactly one row, so the generated + # not-found branch of the count queries needs a connection stub that + # misses. + @staticmethod + def execute(_query: str, _params: object = None) -> NoRowCursor: + """Return a cursor that finds no row. + + Returns + ------- + NoRowCursor + The cursor stub missing every row. + """ + return NoRowCursor() diff --git a/test/driver_psycopg_sync/omit_tc/__init__.py b/test/driver_psycopg_sync/omit_tc/__init__.py new file mode 100644 index 0000000..d38d7fe --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/omit_tc/classes/__init__.py b/test/driver_psycopg_sync/omit_tc/classes/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/omit_tc/classes/enums.py b/test/driver_psycopg_sync/omit_tc/classes/enums.py new file mode 100644 index 0000000..0cfc74e --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/omit_tc/classes/models.py b/test/driver_psycopg_sync/omit_tc/classes/models.py new file mode 100644 index 0000000..62c9ced --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/omit_tc/classes/queries_enum_override.py b/test/driver_psycopg_sync/omit_tc/classes/queries_enum_override.py new file mode 100644 index 0000000..1fda393 --- /dev/null +++ b/test/driver_psycopg_sync/omit_tc/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 +import collections.abc +import psycopg +import psycopg.rows + + +from test.driver_psycopg_sync.omit_tc.classes import enums +from test.driver_psycopg_sync.omit_tc.classes import models + +type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + +type ConnectionLike = psycopg.Connection[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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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. + """ + self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + 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 = 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)}) + + 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 = 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_sync/omit_tc/functions/__init__.py b/test/driver_psycopg_sync/omit_tc/functions/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/omit_tc/functions/enums.py b/test/driver_psycopg_sync/omit_tc/functions/enums.py new file mode 100644 index 0000000..0cfc74e --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/omit_tc/functions/models.py b/test/driver_psycopg_sync/omit_tc/functions/models.py new file mode 100644 index 0000000..62c9ced --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/omit_tc/functions/queries_enum_override.py b/test/driver_psycopg_sync/omit_tc/functions/queries_enum_override.py new file mode 100644 index 0000000..8faa1eb --- /dev/null +++ b/test/driver_psycopg_sync/omit_tc/functions/queries_enum_override.py @@ -0,0 +1,197 @@ +# 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_sync.omit_tc.functions import enums +from test.driver_psycopg_sync.omit_tc.functions import models + +type QueryResultsArgsType = int | float | str | memoryview | collections.abc.Sequence[QueryResultsArgsType] | None + +type ConnectionLike = psycopg.Connection[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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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. + """ + conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +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 = 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)}) + + +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 = 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_sync/omit_tc/ruff.toml b/test/driver_psycopg_sync/omit_tc/ruff.toml new file mode 100644 index 0000000..0fa548a --- /dev/null +++ b/test/driver_psycopg_sync/omit_tc/ruff.toml @@ -0,0 +1,5 @@ +extend="../../../ruff.toml" + + +[lint.pydocstyle] +convention = "google" diff --git a/test/driver_psycopg_sync/omit_tc/test_omit_typechecking_import.py b/test/driver_psycopg_sync/omit_tc/test_omit_typechecking_import.py new file mode 100644 index 0000000..13c4b79 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.omit_tc.classes import queries_enum_override as classes_module +from test.driver_psycopg_sync.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_sync/omit_tc/test_omit_typechecking_runtime.py b/test/driver_psycopg_sync/omit_tc/test_omit_typechecking_runtime.py new file mode 100644 index 0000000..8558944 --- /dev/null +++ b/test/driver_psycopg_sync/omit_tc/test_omit_typechecking_runtime.py @@ -0,0 +1,170 @@ +# 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 call path and the +cursor-based for path) of the classes and functions packages. +""" + +from __future__ import annotations + +import typing + +import pytest + +from test.driver_psycopg_sync.no_row_conn import NoRowConn +from test.driver_psycopg_sync.omit_tc.classes import enums as classes_enums +from test.driver_psycopg_sync.omit_tc.classes import models as classes_models +from test.driver_psycopg_sync.omit_tc.classes import queries_enum_override as classes_queries +from test.driver_psycopg_sync.omit_tc.functions import enums as functions_enums +from test.driver_psycopg_sync.omit_tc.functions import models as functions_models +from test.driver_psycopg_sync.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 TestOmitTcClasses: + @pytest.fixture(scope="session") + def queries_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> classes_queries.QueriesEnumOverride: + return classes_queries.QueriesEnumOverride(conn=psycopg_sync_conn) + + @pytest.mark.dependency(name="TestOmitTcClasses::insert_enum_override") + 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. + queries_obj.insert_enum_override(id_=CLASSES_IDS[0], mood_test="happy") + queries_obj.insert_enum_override(id_=CLASSES_IDS[1], mood_test="sad") + + @pytest.mark.dependency(name="TestOmitTcClasses::get_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + def test_get_enum_override_mood(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + mood = queries_obj.get_enum_override_mood(id_=CLASSES_IDS[0]) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + def test_get_enum_override_mood_not_found(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + assert queries_obj.get_enum_override_mood(id_=MISSING_ID) is None + + @pytest.mark.dependency(name="TestOmitTcClasses::list_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + def test_list_enum_override_by_ids(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + # Calling the QueryResults object fetches all rows in one go. + rows = 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.dependency(name="TestOmitTcClasses::iterate_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + def test_iterate_enum_override_by_ids( + self, + queries_obj: classes_queries.QueriesEnumOverride, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + assert queries_obj.conn is psycopg_sync_conn + results = queries_obj.list_enum_override_by_ids(dollar_1=list(CLASSES_IDS)) + seen: dict[int, str] = {} + # Exercise the cursor-based for path. + with queries_obj.conn.transaction(): + 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.dependency(name="TestOmitTcClasses::count_enum_override", depends=["TestOmitTcClasses::insert_enum_override"]) + def test_count_enum_override_by_moods(self, queries_obj: classes_queries.QueriesEnumOverride) -> None: + count = queries_obj.count_enum_override_by_moods(dollar_1=[classes_enums.TestMood.HAPPY, classes_enums.TestMood.SAD]) + assert count == len(CLASSES_IDS) + assert queries_obj.count_enum_override_by_moods(dollar_1=[classes_enums.TestMood.VALUE_24H]) == 0 + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + stub_queries_obj = classes_queries.QueriesEnumOverride(conn=conn) + count = stub_queries_obj.count_enum_override_by_moods(dollar_1=[classes_enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.dependency(depends=["TestOmitTcClasses::insert_enum_override"]) + def test_delete_enum_override(self, psycopg_sync_conn: psycopg.Connection[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: + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": row_id}) + + +class TestOmitTcFunctions: + @pytest.mark.dependency(name="TestOmitTcFunctions::insert_enum_override") + def test_insert_enum_override(self, psycopg_sync_conn: psycopg.Connection[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. + functions_queries.insert_enum_override(conn=psycopg_sync_conn, id_=FUNCTIONS_IDS[0], mood_test="happy") + functions_queries.insert_enum_override(conn=psycopg_sync_conn, id_=FUNCTIONS_IDS[1], mood_test="sad") + + @pytest.mark.dependency(name="TestOmitTcFunctions::get_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + def test_get_enum_override_mood(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = functions_queries.get_enum_override_mood(conn=psycopg_sync_conn, id_=FUNCTIONS_IDS[0]) + assert mood is not None + assert isinstance(mood, str) + assert mood == "happy" + + def test_get_enum_override_mood_not_found(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert functions_queries.get_enum_override_mood(conn=psycopg_sync_conn, id_=MISSING_ID) is None + + @pytest.mark.dependency(name="TestOmitTcFunctions::list_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + def test_list_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # Calling the QueryResults object fetches all rows in one go. + rows = functions_queries.list_enum_override_by_ids(conn=psycopg_sync_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.dependency(name="TestOmitTcFunctions::iterate_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + def test_iterate_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + results = functions_queries.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=list(FUNCTIONS_IDS)) + seen: dict[int, str] = {} + # Exercise the cursor-based for path. + with psycopg_sync_conn.transaction(): + 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.dependency(name="TestOmitTcFunctions::count_enum_override", depends=["TestOmitTcFunctions::insert_enum_override"]) + def test_count_enum_override_by_moods(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + count = functions_queries.count_enum_override_by_moods(conn=psycopg_sync_conn, dollar_1=[functions_enums.TestMood.HAPPY, functions_enums.TestMood.SAD]) + assert count == len(FUNCTIONS_IDS) + assert functions_queries.count_enum_override_by_moods(conn=psycopg_sync_conn, dollar_1=[functions_enums.TestMood.VALUE_24H]) == 0 + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + count = functions_queries.count_enum_override_by_moods(conn=conn, dollar_1=[functions_enums.TestMood.HAPPY]) + assert count is None + + @pytest.mark.dependency(depends=["TestOmitTcFunctions::insert_enum_override"]) + def test_delete_enum_override(self, psycopg_sync_conn: psycopg.Connection[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: + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": row_id}) diff --git a/test/driver_psycopg_sync/pydantic/__init__.py b/test/driver_psycopg_sync/pydantic/__init__.py new file mode 100644 index 0000000..242b9d5 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/pydantic/classes/__init__.py b/test/driver_psycopg_sync/pydantic/classes/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/pydantic/classes/enums.py b/test/driver_psycopg_sync/pydantic/classes/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/pydantic/classes/models.py b/test/driver_psycopg_sync/pydantic/classes/models.py new file mode 100644 index 0000000..71ae13f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/pydantic/classes/queries.py b/test/driver_psycopg_sync/pydantic/classes/queries.py new file mode 100644 index 0000000..9a57ce9 --- /dev/null +++ b/test/driver_psycopg_sync/pydantic/classes/queries.py @@ -0,0 +1,2086 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.pydantic.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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 = 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], + ) + + 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 = 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], + ) + + 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 = self._conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + 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 = 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_}) + + 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 = 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], + ), + ) + + 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 = 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], + ), + ) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + 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, + } + self._conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + 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. + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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. + """ + self._conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + 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.Cursor[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.Cursor[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 self._conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + def update_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return self._conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + def delete_one_result_test_postgres_type(self, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return self._conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + 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 = self._conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + 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 = self._conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + 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 = self._conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + 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. + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + 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. + """ + self._conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + 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 = 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_}) + + 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 = 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_}) + + 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. + """ + self._conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + 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. + """ + self._conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + 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 = 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) + + 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 = 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) + + 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 = self._conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/pydantic/classes/queries_copy_override.py b/test/driver_psycopg_sync/pydantic/classes/queries_copy_override.py new file mode 100644 index 0000000..f9149bb --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 + + 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. + """ + with self._conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + 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 = self._conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + def delete_copy_override_rows(self) -> None: + """Execute SQL query with `name: DeleteCopyOverrideRows :exec`. + + ```sql + DELETE FROM test_copy_override + ``` + + """ + self._conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/pydantic/classes/queries_enum_override.py b/test/driver_psycopg_sync/pydantic/classes/queries_enum_override.py new file mode 100644 index 0000000..6486fdc --- /dev/null +++ b/test/driver_psycopg_sync/pydantic/classes/queries_enum_override.py @@ -0,0 +1,207 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.pydantic.classes import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + 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 + + 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. + """ + self._conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + 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 = 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)}) + + 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 = 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_sync/pydantic/classes/queries_field_namings.py b/test/driver_psycopg_sync/pydantic/classes/queries_field_namings.py new file mode 100644 index 0000000..cef8257 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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 = self._conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + 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 = 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]) + + 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. + """ + self._conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/pydantic/classes/queries_invalid_identifiers.py b/test/driver_psycopg_sync/pydantic/classes/queries_invalid_identifiers.py new file mode 100644 index 0000000..e24beaa --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 + + 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. + """ + self._conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + 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 = 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]) + + 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. + """ + self._conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + 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 = 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_sync/pydantic/functions/__init__.py b/test/driver_psycopg_sync/pydantic/functions/__init__.py new file mode 100644 index 0000000..775f83f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/pydantic/functions/enums.py b/test/driver_psycopg_sync/pydantic/functions/enums.py new file mode 100644 index 0000000..734b78b --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/pydantic/functions/models.py b/test/driver_psycopg_sync/pydantic/functions/models.py new file mode 100644 index 0000000..7caa49c --- /dev/null +++ b/test/driver_psycopg_sync/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_sync.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_sync/pydantic/functions/queries.py b/test/driver_psycopg_sync/pydantic/functions/queries.py new file mode 100644 index 0000000..4883530 --- /dev/null +++ b/test/driver_psycopg_sync/pydantic/functions/queries.py @@ -0,0 +1,2197 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.pydantic.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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 = 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], + ) + + +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 = 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], + ) + + +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 = conn.execute(GET_ONE_TEST_TIMESTAMP_POSTGRES_TYPE, {"p1": id_}).fetchone() + if row is None: + return None + return row[0] + + +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 = 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_}) + + +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 = 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], + ), + ) + + +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 = 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], + ), + ) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_TYPE, sql_params) + + +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, + } + conn.execute(CREATE_ONE_TEST_POSTGRES_INNER_TYPE, sql_params) + + +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. + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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. + """ + conn.execute(DELETE_ONE_TEST_POSTGRES_INNER_TYPE, {"p1": table_id}) + + +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.Cursor[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.Cursor[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 conn.execute(CREATE_RESULT_ONE_TEST_POSTGRES_TYPE, sql_params) + + +def update_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return conn.execute(UPDATE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +def delete_one_result_test_postgres_type(conn: ConnectionLike, *, id_: int) -> psycopg.Cursor[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.Cursor[psycopg.rows.TupleRow]` returned when executing the query. + """ + return conn.execute(DELETE_ONE_RESULT_TEST_POSTGRES_TYPE, {"p1": id_}) + + +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 = conn.execute(CREATE_ROWS_ONE_TEST_POSTGRES_TYPE, sql_params) + return cur.rowcount + + +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 = conn.execute(UPDATE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(DELETE_ONE_ROWS_TEST_POSTGRES_TYPE, {"p1": id_}) + return cur.rowcount + + +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 = conn.execute(CREATE_ROWS_TABLE) + return cur.rowcount + + +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. + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_from" ("id", "float_test", "int_test") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, param.float_test, param.int_test)) + return cur.rowcount + + +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. + """ + conn.execute(INSERT_TYPE_OVERRIDE, {"p1": id_, "p2": str(text_test) if text_test is not None else None}) + + +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 = 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_}) + + +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 = 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_}) + + +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. + """ + conn.execute(DELETE_TYPE_OVERRIDE, {"p1": id_}) + + +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. + """ + conn.execute(INSERT_ONE_TEST_ENUM_TYPE, {"p1": id_, "p2": mood, "p3": maybe_mood}) + + +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 = 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) + + +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 = 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) + + +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 = conn.execute(DELETE_ONE_TEST_ENUM_TYPE, {"p1": id_}) + return cur.rowcount diff --git a/test/driver_psycopg_sync/pydantic/functions/queries_copy_override.py b/test/driver_psycopg_sync/pydantic/functions/queries_copy_override.py new file mode 100644 index 0000000..e377ce7 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[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 +""" + + +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. + """ + with conn.cursor() as cur: + with cur.copy('COPY "test_copy_override" ("id", "amount", "co""l") FROM STDIN') as copy: + for param in params: + copy.write_row((param.id_, decimal.Decimal(param.amount), param.co_l)) + return cur.rowcount + + +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 = conn.execute(COUNT_COPY_OVERRIDE_ROWS).fetchone() + if row is None: + return None + return row[0] + + +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. + """ + conn.execute(DELETE_COPY_OVERRIDE_ROWS) diff --git a/test/driver_psycopg_sync/pydantic/functions/queries_enum_override.py b/test/driver_psycopg_sync/pydantic/functions/queries_enum_override.py new file mode 100644 index 0000000..6ae8f59 --- /dev/null +++ b/test/driver_psycopg_sync/pydantic/functions/queries_enum_override.py @@ -0,0 +1,198 @@ +# 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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.pydantic.functions import enums +from test.driver_psycopg_sync.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.Cursor[psycopg.rows.TupleRow] | None = None + self._iterator: collections.abc.Iterator[psycopg.rows.TupleRow] | None = None + + def __iter__(self) -> QueryResults[T]: + """Initialize iteration support. + + Returns: + Self as an iterator. + """ + return self + + def __call__( + self, + ) -> collections.abc.Sequence[T]: + """Allow calling the object to return all rows as a fully decoded sequence. + + Returns: + A sequence of decoded objects of type `T`. + """ + result = self._conn.execute(self._sql, self._params).fetchall() + return [self._decode_hook(row) for row in result] + + def __next__(self) -> T: + """Yield the next item in the query result using a psycopg cursor. + + Returns: + The next decoded result of type `T`. + + Raises: + StopIteration: When no more records are available. + """ + if self._cursor is None or self._iterator is None: + self._cursor = self._conn.execute(self._sql, self._params) + self._iterator = self._cursor.__iter__() + try: + record = self._iterator.__next__() + except StopIteration: + self._cursor = None + self._iterator = None + raise + return self._decode_hook(record) + + +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. + """ + conn.execute(INSERT_ENUM_OVERRIDE, {"p1": id_, "p2": enums.TestMood(mood_test)}) + + +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 = 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)}) + + +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 = 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_sync/pydantic/functions/queries_field_namings.py b/test/driver_psycopg_sync/pydantic/functions/queries_field_namings.py new file mode 100644 index 0000000..5e7c239 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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 = conn.execute(GET_FIELD_NAMING, {"p1": id_}).fetchone() + if row is None: + return None + return models.TestFieldNaming(id_=row[0], outputs=row[1]) + + +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 = conn.execute(GET_JOINED_FIELD_NAMINGS, {"p1": id_}).fetchone() + if row is None: + return None + return GetJoinedFieldNamingsRow(outputs=row[0], outputs_2=row[1]) + + +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. + """ + conn.execute(SET_FIELD_NAMING_OUTPUTS, {"p1": id_, "p2": outputs, "p3": outputs_2}) diff --git a/test/driver_psycopg_sync/pydantic/functions/queries_invalid_identifiers.py b/test/driver_psycopg_sync/pydantic/functions/queries_invalid_identifiers.py new file mode 100644 index 0000000..c914764 --- /dev/null +++ b/test/driver_psycopg_sync/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.Connection[psycopg.rows.TupleRow] + +from test.driver_psycopg_sync.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 +""" + + +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. + """ + conn.execute(INSERT_INVALID_IDENTIFIERS, {"p1": id_, "p2": column_3p_, "p3": new_notes}) + + +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 = 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]) + + +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. + """ + conn.execute(INSERT_THIRD_PARTY_STAT, {"p1": id_, "p2": total}) + + +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 = 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_sync/pydantic/ruff.toml b/test/driver_psycopg_sync/pydantic/ruff.toml new file mode 100644 index 0000000..ded540a --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/pydantic/test_psycopg_sync_pydantic_classes.py b/test/driver_psycopg_sync/pydantic/test_psycopg_sync_pydantic_classes.py new file mode 100644 index 0000000..d7f6fc3 --- /dev/null +++ b/test/driver_psycopg_sync/pydantic/test_psycopg_sync_pydantic_classes.py @@ -0,0 +1,771 @@ +# 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 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_sync.no_row_conn import NoRowConn +from test.driver_psycopg_sync.pydantic.classes import enums +from test.driver_psycopg_sync.pydantic.classes import models +from test.driver_psycopg_sync.pydantic.classes import queries +from test.driver_psycopg_sync.pydantic.classes import queries_enum_override + + +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.fixture(scope="session") + def queries_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries.Queries: + return queries.Queries(conn=psycopg_sync_conn) + + @pytest.mark.dependency(name="TestPydanticClasses::create") + def test_create(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + 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.dependency(name="TestPydanticClasses::create_inner", depends=["TestPydanticClasses::create"]) + def test_create_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + 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.dependency(depends=["TestPydanticClasses::create_inner"], name="TestPydanticClasses::get_one") + def test_get_one(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_one"], name="TestPydanticClasses::get_one_none") + def test_get_one_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one_none"], name="TestPydanticClasses::get_one_inner") + def test_get_one_inner(self, queries_obj: queries.Queries, inner_model: models.TestInnerPostgresType) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_one_inner"], name="TestPydanticClasses::get_one_inner_none") + def test_get_one_inner_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_inner_test_postgres_type(table_id=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_one_inner_none"], + name="TestPydanticClasses::get_one_timestamp", + ) + def test_get_one_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_one_timestamp"], name="TestPydanticClasses::get_one_timestamp_none") + def test_get_one_timestamp_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_timestamp_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_one_timestamp_none"], + name="TestPydanticClasses::get_one_bytea", + ) + def test_get_one_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_one_bytea"], name="TestPydanticClasses::get_one_bytea_none") + def test_get_one_bytea_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_bytea_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestPydanticClasses::get_one_bytea_none"], name="TestPydanticClasses::get_many") + def test_get_many(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_many"], name="TestPydanticClasses::get_many_timestamp") + def test_get_many_timestamp(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency( + depends=["TestPydanticClasses::get_many_timestamp"], + name="TestPydanticClasses::get_many_bytea", + ) + def test_get_many_bytea(self, queries_obj: queries.Queries, model: models.TestPostgresType) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_many_bytea"], name="TestPydanticClasses::get_embedded") + def test_get_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_embedded"], name="TestPydanticClasses::get_embedded_none") + def test_get_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_embedded_none"], + name="TestPydanticClasses::get_all_embedded", + ) + def test_get_all_embedded( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = 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.dependency(depends=["TestPydanticClasses::get_all_embedded"], name="TestPydanticClasses::get_all_embedded_none") + def test_get_all_embedded_none( + self, + queries_obj: queries.Queries, + ) -> None: + result = queries_obj.get_all_embedded_test_postgres_type(id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticClasses::get_all_embedded_none"], + name="TestPydanticClasses::get_many_iterator", + ) + 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_) + with queries_obj.conn.transaction(): + for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestPydanticClasses::get_many_iterator"], name="TestPydanticClasses::delete") + def test_delete( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_type(id_=model.id_) + + @pytest.mark.dependency(depends=["TestPydanticClasses::delete"], name="TestPydanticClasses::delete_inner") + def test_delete_inner( + self, + queries_obj: queries.Queries, + inner_model: models.TestInnerPostgresType, + ) -> None: + queries_obj.delete_one_test_postgres_inner_type(table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestPydanticClasses::create_result") + def test_create_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestPydanticClasses::create_result"], name="TestPydanticClasses::update_result") + def test_update_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency(depends=["TestPydanticClasses::update_result"], name="TestPydanticClasses::delete_result") + def test_delete_result( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_result_test_postgres_type(id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestPydanticClasses::create_rows") + def test_create_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = 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.dependency(depends=["TestPydanticClasses::create_rows"], name="TestPydanticClasses::update_rows") + def test_update_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.update_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestPydanticClasses::update_rows"], name="TestPydanticClasses::delete_rows") + def test_delete_rows( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + ) -> None: + result = queries_obj.delete_one_rows_test_postgres_type(id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestPydanticClasses::delete_rows"], name="TestPydanticClasses::copy_from") + def test_copy_from( + self, + queries_obj: queries.Queries, + model: models.TestPostgresType, + psycopg_sync_conn: psycopg.Connection[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 = queries_obj.test_copy_from(params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + queries_obj: queries.Queries, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries_obj.create_rows_table() + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestPydanticClasses::insert_type_override", + ) + def test_insert_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.insert_type_override(id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_type_override", + depends=["TestPydanticClasses::insert_type_override"], + ) + def test_get_one_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_type_override_none", + depends=["TestPydanticClasses::get_one_type_override"], + ) + def test_get_one_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestPydanticClasses::get_many_type_override", + depends=["TestPydanticClasses::get_one_type_override_none"], + ) + def test_get_many_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_many_type_override(id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_text_type_override", + depends=["TestPydanticClasses::get_many_type_override"], + ) + def test_get_one_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestPydanticClasses::get_one_text_type_override_none", + depends=["TestPydanticClasses::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = queries_obj.get_one_text_type_override(id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestPydanticClasses::get_many_text_type_override", + depends=["TestPydanticClasses::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + result = 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.dependency( + name="TestPydanticClasses::delete_type_override", + depends=["TestPydanticClasses::get_many_text_type_override"], + ) + def test_delete_type_override(self, queries_obj: queries.Queries, override_model: models.TestTypeOverride) -> None: + queries_obj.delete_type_override(id_=override_model.id_) + + 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.dependency(name="TestPydanticClasses::insert_enum") + def test_insert_enum(self, queries_obj: queries.Queries) -> None: + queries_obj.insert_one_test_enum_type(id_=510006, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestPydanticClasses::get_enum", depends=["TestPydanticClasses::insert_enum"]) + def test_get_enum(self, queries_obj: queries.Queries) -> None: + result = 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.dependency(name="TestPydanticClasses::get_enum_value", depends=["TestPydanticClasses::get_enum"]) + def test_get_enum_value(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=510006) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum"]) + def test_get_enum_none(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_one_test_enum_type(id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum"]) + def test_get_enum_value_none(self, queries_obj: queries.Queries) -> None: + mood = queries_obj.get_one_test_enum_value(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestPydanticClasses::get_many_enums", depends=["TestPydanticClasses::get_enum_value"]) + def test_get_many_enums(self, queries_obj: queries.Queries) -> None: + result = queries_obj.get_many_test_enum_types()() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestPydanticClasses::get_many_enums"]) + def test_delete_enum(self, queries_obj: queries.Queries) -> None: + assert queries_obj.delete_one_test_enum_type(id_=510006) == 1 + + @pytest.fixture(scope="session") + def queries_enum_override_obj(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> queries_enum_override.QueriesEnumOverride: + return queries_enum_override.QueriesEnumOverride(conn=psycopg_sync_conn) + + @pytest.mark.dependency(name="TestPydanticClasses::insert_enum_override") + 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. + queries_enum_override_obj.insert_enum_override(id_=520006, mood_test="24h") + + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum_override"]) + def test_get_enum_override(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=520006) + assert mood is not None + assert isinstance(mood, str) + assert mood == "24h" + + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum_override"]) + def test_get_enum_override_none(self, queries_enum_override_obj: queries_enum_override.QueriesEnumOverride) -> None: + mood = queries_enum_override_obj.get_enum_override_mood(id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestPydanticClasses::list_enum_override", depends=["TestPydanticClasses::insert_enum_override"]) + 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 = queries_enum_override_obj.list_enum_override_by_ids(dollar_1=[520006])() + assert len(rows) == 1 + assert rows[0].mood_test == "24h" + + @pytest.mark.dependency(depends=["TestPydanticClasses::insert_enum_override"]) + 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 for path; going through the conn + # property also covers its generated accessor. + with queries_enum_override_obj.conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520006: "24h"} + + @pytest.mark.dependency(name="TestPydanticClasses::count_enum_override", depends=["TestPydanticClasses::insert_enum_override"]) + 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 = queries_enum_override_obj.count_enum_override_by_moods(dollar_1=[enums.TestMood.VALUE_24H, enums.TestMood.SAD]) + assert count == 1 + + @pytest.mark.dependency(depends=["TestPydanticClasses::count_enum_override"]) + def test_cleanup_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520006}) + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + no_row_queries = queries_enum_override.QueriesEnumOverride(conn=conn) + count = no_row_queries.count_enum_override_by_moods(dollar_1=[enums.TestMood.VALUE_24H]) + assert count is None diff --git a/test/driver_psycopg_sync/pydantic/test_psycopg_sync_pydantic_functions.py b/test/driver_psycopg_sync/pydantic/test_psycopg_sync_pydantic_functions.py new file mode 100644 index 0000000..8c6fcef --- /dev/null +++ b/test/driver_psycopg_sync/pydantic/test_psycopg_sync_pydantic_functions.py @@ -0,0 +1,838 @@ +# 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 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_sync.no_row_conn import NoRowConn +from test.driver_psycopg_sync.pydantic.functions import enums +from test.driver_psycopg_sync.pydantic.functions import models +from test.driver_psycopg_sync.pydantic.functions import queries +from test.driver_psycopg_sync.pydantic.functions import queries_enum_override + + +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.dependency(name="TestPydanticFunctions::create") + def test_create( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.create_one_test_postgres_type( + conn=psycopg_sync_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.dependency(name="TestPydanticFunctions::create2", depends=["TestPydanticFunctions::create"]) + def test_create_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.create_one_test_postgres_inner_type( + conn=psycopg_sync_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.dependency(depends=["TestPydanticFunctions::create2"], name="TestPydanticFunctions::get_one") + def test_get_one( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one"], name="TestPydanticFunctions::get_one_none") + def test_get_one_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one_none"], name="TestPydanticFunctions::get_one_inner") + def test_get_one_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + assert result is not None + assert isinstance(result, models.TestInnerPostgresType) + + assert result == inner_model + + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one_inner"], name="TestPydanticFunctions::get_one_inner_none") + def test_get_one_inner_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_inner_test_postgres_type(conn=psycopg_sync_conn, table_id=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_inner_none"], + name="TestPydanticFunctions::get_one_timestamp", + ) + def test_get_one_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, datetime.datetime) + assert result == model.timestamp_test + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_timestamp"], + name="TestPydanticFunctions::get_one_timestamp_none", + ) + def test_get_one_timestamp_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_timestamp_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_timestamp_none"], + name="TestPydanticFunctions::get_one_bytea", + ) + def test_get_one_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + assert result is not None + assert isinstance(result, memoryview) + assert result == model.bytea_test + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_one_bytea"], + name="TestPydanticFunctions::get_one_bytea_none", + ) + def test_get_one_bytea_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_one_test_bytea_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_one_bytea_none"], name="TestPydanticFunctions::get_many") + def test_get_many( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestPydanticFunctions::get_many"], + name="TestPydanticFunctions::get_many_timestamp", + ) + def test_get_many_timestamp( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_timestamp_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestPydanticFunctions::get_many_timestamp"], + name="TestPydanticFunctions::get_many_bytea", + ) + def test_get_many_bytea( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.get_many_test_bytea_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestPydanticFunctions::get_many_bytea"], + name="TestPydanticFunctions::get_embedded", + ) + def test_get_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestPydanticFunctions::get_embedded"], + name="TestPydanticFunctions::get_embedded_none", + ) + def test_get_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_embedded_none"], + name="TestPydanticFunctions::get_all_embedded", + ) + def test_get_all_embedded( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + inner_model: models.TestInnerPostgresType, + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_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.dependency( + depends=["TestPydanticFunctions::get_all_embedded"], + name="TestPydanticFunctions::get_all_embedded_none", + ) + def test_get_all_embedded_none( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.get_all_embedded_test_postgres_type(conn=psycopg_sync_conn, id_=0) + + assert result is None + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_all_embedded_none"], + name="TestPydanticFunctions::get_many_iterator", + ) + def test_get_many_iterator( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + results = queries.get_many_test_iterator_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + with psycopg_sync_conn.transaction(): + for result in results: + assert result is not None + assert isinstance(result, models.TestPostgresType) + + assert result == model + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::get_many_iterator"], + name="TestPydanticFunctions::delete", + ) + def test_delete( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + queries.delete_one_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_) + + @pytest.mark.dependency(depends=["TestPydanticFunctions::delete"], name="TestPydanticFunctions::delete_inner") + def test_delete_inner( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + inner_model: models.TestInnerPostgresType, + ) -> None: + queries.delete_one_test_postgres_inner_type(conn=psycopg_sync_conn, table_id=inner_model.table_id) + + @pytest.mark.dependency(name="TestPydanticFunctions::create_result") + def test_create_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_result_one_test_postgres_type( + conn=psycopg_sync_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.dependency( + depends=["TestPydanticFunctions::create_result"], + name="TestPydanticFunctions::update_result", + ) + def test_update_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "UPDATE 1" + + @pytest.mark.dependency( + depends=["TestPydanticFunctions::update_result"], + name="TestPydanticFunctions::delete_result", + ) + def test_delete_result( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_result_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result.statusmessage == "DELETE 1" + + @pytest.mark.dependency(name="TestPydanticFunctions::create_rows") + def test_create_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.create_rows_one_test_postgres_type( + conn=psycopg_sync_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.dependency(depends=["TestPydanticFunctions::create_rows"], name="TestPydanticFunctions::update_rows") + def test_update_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.update_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestPydanticFunctions::update_rows"], name="TestPydanticFunctions::delete_rows") + def test_delete_rows( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + model: models.TestPostgresType, + ) -> None: + result = queries.delete_one_rows_test_postgres_type(conn=psycopg_sync_conn, id_=model.id_ + 1) + + assert result == 1 + + @pytest.mark.dependency(depends=["TestPydanticFunctions::delete_rows"], name="TestPydanticFunctions::copy_from") + def test_copy_from( + self, + psycopg_sync_conn: psycopg.Connection[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 = queries.test_copy_from(conn=psycopg_sync_conn, params=rows) + assert result == num + psycopg_sync_conn.execute("""DELETE FROM test_copy_from;""") + + def test_create_table( + self, + psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], + ) -> None: + result = queries.create_rows_table(conn=psycopg_sync_conn) + + assert result == -1 + + psycopg_sync_conn.execute("""DROP TABLE test_create_rows_table;""") + + @pytest.mark.dependency( + name="TestPydanticFunctions::insert_type_override", + ) + def test_insert_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.insert_type_override(conn=psycopg_sync_conn, id_=override_model.id_, text_test=override_model.text_test) + + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_type_override", + depends=["TestPydanticFunctions::insert_type_override"], + ) + def test_get_one_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model + + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_type_override_none", + depends=["TestPydanticFunctions::get_one_type_override"], + ) + def test_get_one_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestPydanticFunctions::get_many_type_override", + depends=["TestPydanticFunctions::get_one_type_override_none"], + ) + def test_get_many_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model + + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_text_type_override", + depends=["TestPydanticFunctions::get_many_type_override"], + ) + def test_get_one_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + assert result is not None + assert result == override_model.text_test + + @pytest.mark.dependency( + name="TestPydanticFunctions::get_one_text_type_override_none", + depends=["TestPydanticFunctions::get_one_text_type_override"], + ) + def test_get_one_text_type_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_one_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_ - 1) + assert result is None + + @pytest.mark.dependency( + name="TestPydanticFunctions::get_many_text_type_override", + depends=["TestPydanticFunctions::get_one_text_type_override_none"], + ) + def test_get_many_text_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + result = queries.get_many_text_type_override(conn=psycopg_sync_conn, id_=override_model.id_)() + assert isinstance(result, collections.abc.Sequence) + assert result[0] == override_model.text_test + + @pytest.mark.dependency( + name="TestPydanticFunctions::delete_type_override", + depends=["TestPydanticFunctions::get_many_text_type_override"], + ) + def test_delete_type_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow], override_model: models.TestTypeOverride) -> None: + queries.delete_type_override(conn=psycopg_sync_conn, id_=override_model.id_) + + 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.dependency(name="TestPydanticFunctions::insert_enum") + def test_insert_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + queries.insert_one_test_enum_type(conn=psycopg_sync_conn, id_=510007, mood=enums.TestMood.HAPPY, maybe_mood=None) + + @pytest.mark.dependency(name="TestPydanticFunctions::get_enum", depends=["TestPydanticFunctions::insert_enum"]) + def test_get_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_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.dependency(name="TestPydanticFunctions::get_enum_value", depends=["TestPydanticFunctions::get_enum"]) + def test_get_enum_value(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=510007) + assert isinstance(mood, enums.TestMood) + assert mood is enums.TestMood.HAPPY + + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum"]) + def test_get_enum_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_one_test_enum_type(conn=psycopg_sync_conn, id_=987654321) + assert result is None + + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum"]) + def test_get_enum_value_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries.get_one_test_enum_value(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestPydanticFunctions::get_many_enums", depends=["TestPydanticFunctions::get_enum_value"]) + def test_get_many_enums(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + result = queries.get_many_test_enum_types(conn=psycopg_sync_conn)() + assert len(result) >= 1 + assert all(isinstance(row.mood, enums.TestMood) for row in result) + + @pytest.mark.dependency(depends=["TestPydanticFunctions::get_many_enums"]) + def test_delete_enum(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + assert queries.delete_one_test_enum_type(conn=psycopg_sync_conn, id_=510007) == 1 + + @pytest.mark.dependency(name="TestPydanticFunctions::insert_enum_override") + def test_insert_enum_override(self, psycopg_sync_conn: psycopg.Connection[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. + queries_enum_override.insert_enum_override(conn=psycopg_sync_conn, id_=520007, mood_test="_hidden") + + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum_override"]) + def test_get_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=520007) + assert mood is not None + assert isinstance(mood, str) + assert mood == "_hidden" + + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum_override"]) + def test_get_enum_override_none(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + mood = queries_enum_override.get_enum_override_mood(conn=psycopg_sync_conn, id_=987654321) + assert mood is None + + @pytest.mark.dependency(name="TestPydanticFunctions::list_enum_override", depends=["TestPydanticFunctions::insert_enum_override"]) + def test_list_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # :many with an array parameter: the Sequence must pass both pyright + # (QueryResultsArgsType) and the runtime QueryResults plumbing. + rows = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[520007])() + assert len(rows) == 1 + assert rows[0].mood_test == "_hidden" + + @pytest.mark.dependency(depends=["TestPydanticFunctions::insert_enum_override"]) + def test_iterate_enum_override_by_ids(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + results = queries_enum_override.list_enum_override_by_ids(conn=psycopg_sync_conn, dollar_1=[520007]) + seen: dict[int, str] = {} + # Exercise the cursor-based for path. + with psycopg_sync_conn.transaction(): + for row in results: + assert isinstance(row, models.TestEnumOverride) + seen[row.id_] = row.mood_test + assert seen == {520007: "_hidden"} + + @pytest.mark.dependency(name="TestPydanticFunctions::count_enum_override", depends=["TestPydanticFunctions::insert_enum_override"]) + def test_count_enum_override_by_moods(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + # No HAPPY in the list: other suites may leave happy rows behind and + # would break the exact count. + count = queries_enum_override.count_enum_override_by_moods(conn=psycopg_sync_conn, dollar_1=[enums.TestMood.VALUE__HIDDEN, enums.TestMood.SAD]) + assert count == 1 + + def test_count_enum_override_no_row(self) -> None: + conn = typing.cast("psycopg.Connection[psycopg.rows.TupleRow]", NoRowConn()) + count = queries_enum_override.count_enum_override_by_moods(conn=conn, dollar_1=[enums.TestMood.VALUE__HIDDEN]) + assert count is None + + @pytest.mark.dependency(depends=["TestPydanticFunctions::count_enum_override"]) + def test_cleanup_enum_override(self, psycopg_sync_conn: psycopg.Connection[psycopg.rows.TupleRow]) -> None: + psycopg_sync_conn.execute("DELETE FROM test_enum_override WHERE id = %(id)s", {"id": 520007}) diff --git a/test/driver_psycopg_sync/queries.sql b/test/driver_psycopg_sync/queries.sql new file mode 100644 index 0000000..2c3ea10 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/queries_converters.sql b/test/driver_psycopg_sync/queries_converters.sql new file mode 100644 index 0000000..ce98ab6 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/queries_copy_override.sql b/test/driver_psycopg_sync/queries_copy_override.sql new file mode 100644 index 0000000..d6ed1ec --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/queries_enum_override.sql b/test/driver_psycopg_sync/queries_enum_override.sql new file mode 100644 index 0000000..e91b74c --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/queries_field_namings.sql b/test/driver_psycopg_sync/queries_field_namings.sql new file mode 100644 index 0000000..0bdd93f --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/queries_invalid_identifiers.sql b/test/driver_psycopg_sync/queries_invalid_identifiers.sql new file mode 100644 index 0000000..91d8653 --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/schema.sql b/test/driver_psycopg_sync/schema.sql new file mode 100644 index 0000000..33c727a --- /dev/null +++ b/test/driver_psycopg_sync/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_sync/sqlc-gen-better-python.wasm b/test/driver_psycopg_sync/sqlc-gen-better-python.wasm new file mode 100755 index 0000000..e08b1b0 Binary files /dev/null and b/test/driver_psycopg_sync/sqlc-gen-better-python.wasm differ diff --git a/test/driver_psycopg_sync/sqlc.yaml b/test/driver_psycopg_sync/sqlc.yaml new file mode 100644 index 0000000..71dac1b --- /dev/null +++ b/test/driver_psycopg_sync/sqlc.yaml @@ -0,0 +1,330 @@ +version: "2" +plugins: + - name: python + wasm: + url: file://sqlc-gen-better-python.wasm + sha256: 390a7b913db2e1e667ff45c4db14a79aea5d4d818ffe31549c92545897a130bf +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_sync.attrs.classes + sql_driver: psycopg_sync + 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_sync.attrs.functions + sql_driver: psycopg_sync + 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_sync.dataclass.classes + sql_driver: psycopg_sync + 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_sync.dataclass.functions + sql_driver: psycopg_sync + 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_sync.msgspec.classes + sql_driver: psycopg_sync + 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_sync.msgspec.functions + sql_driver: psycopg_sync + 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_sync.pydantic.classes + sql_driver: psycopg_sync + 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_sync.pydantic.functions + sql_driver: psycopg_sync + 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_sync.omit_tc.classes + sql_driver: psycopg_sync + 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_sync.omit_tc.functions + sql_driver: psycopg_sync + 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/sqlc-gen-better-python.wasm b/test/driver_sqlite3/sqlc-gen-better-python.wasm index b1ae5d8..e08b1b0 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 d4c221e..8e0fc45 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: 1a125181baa3972863842614054215a1129e83026a9c5c1306bc25edda091782 + sha256: 390a7b913db2e1e667ff45c4db14a79aea5d4d818ffe31549c92545897a130bf sql: - schema: schema.sql queries: